diff --git a/.gitattributes b/.gitattributes index a6344aac8c09253b3b630fb776ae94478aa0275b..fa14483fee2a0847aac258f0ddfa926ccf13f5fc 100644 --- a/.gitattributes +++ b/.gitattributes @@ -33,3 +33,49 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text *.zip filter=lfs diff=lfs merge=lfs -text *.zst filter=lfs diff=lfs merge=lfs -text *tfevents* filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.Infrastructure/obj/Debug/net10.0/RoslynStone.Infrastructure.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.Infrastructure/obj/Debug/net10.0/RoslynStone.Infrastructure.pdb filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.Infrastructure/obj/Release/net10.0/RoslynStone.Infrastructure.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.Infrastructure/bin/Debug/net10.0/RoslynStone.Infrastructure.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.Infrastructure/obj/Release/net10.0/RoslynStone.Infrastructure.pdb filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.Infrastructure/bin/Debug/net10.0/RoslynStone.Infrastructure.pdb filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.Infrastructure/bin/Release/net10.0/RoslynStone.Infrastructure.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.Infrastructure/bin/Release/net10.0/RoslynStone.Infrastructure.pdb filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Debug/net10.0/Grpc.AspNetCore.Server.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Debug/net10.0/MessagePack.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Debug/net10.0/Newtonsoft.Json.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Debug/net10.0/Nerdbank.Streams.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Debug/net10.0/YamlDotNet.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Debug/net10.0/StreamJsonRpc.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Debug/net10.0/Google.Protobuf.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Debug/net10.0/Polly.Core.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Debug/net10.0/Microsoft.VisualStudio.Threading.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Debug/net10.0/Aspire.Hosting.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Debug/net10.0/OpenTelemetry.Exporter.OpenTelemetryProtocol.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Debug/net10.0/Microsoft.Extensions.Http.Resilience.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Debug/net10.0/Microsoft.Extensions.Telemetry.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Debug/net10.0/Grpc.Net.Client.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Debug/net10.0/KubernetesClient.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Debug/net10.0/Humanizer.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Debug/net10.0/Microsoft.Extensions.Http.Diagnostics.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Debug/net10.0/OpenTelemetry.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Release/net10.0/Grpc.AspNetCore.Server.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Release/net10.0/MessagePack.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Debug/net10.0/runtimes/win/lib/net10.0/System.Diagnostics.EventLog.Messages.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Release/net10.0/Nerdbank.Streams.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Release/net10.0/Newtonsoft.Json.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Release/net10.0/YamlDotNet.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Release/net10.0/Aspire.Hosting.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Release/net10.0/Google.Protobuf.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Release/net10.0/StreamJsonRpc.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Release/net10.0/Polly.Core.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Release/net10.0/Microsoft.VisualStudio.Threading.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Release/net10.0/OpenTelemetry.Exporter.OpenTelemetryProtocol.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Release/net10.0/Microsoft.Extensions.Http.Resilience.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Release/net10.0/KubernetesClient.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Release/net10.0/Grpc.Net.Client.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Release/net10.0/Microsoft.Extensions.Telemetry.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Release/net10.0/Humanizer.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Release/net10.0/Microsoft.Extensions.Http.Diagnostics.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Release/net10.0/OpenTelemetry.dll filter=lfs diff=lfs merge=lfs -text +src/RoslynStone.AppHost/bin/Release/net10.0/runtimes/win/lib/net10.0/System.Diagnostics.EventLog.Messages.dll filter=lfs diff=lfs merge=lfs -text diff --git a/.github/actions/setup-dotnet-tools/action.yml b/.github/actions/setup-dotnet-tools/action.yml new file mode 100644 index 0000000000000000000000000000000000000000..f14faa463d84ee86ce0d083ab7734ea13675b6cd --- /dev/null +++ b/.github/actions/setup-dotnet-tools/action.yml @@ -0,0 +1,54 @@ +name: 'Setup .NET Tools' +description: 'Sets up .NET SDK and all development tools (CSharpier, ReSharper, Cake, dotnet-outdated)' +inputs: + dotnet-version: + description: '.NET SDK version to install' + required: false + default: '10.0.x' +runs: + using: 'composite' + steps: + - name: Setup .NET + uses: actions/setup-dotnet@v4 + with: + dotnet-version: ${{ inputs.dotnet-version }} + + - name: Display .NET version + shell: bash + run: dotnet --version + + - name: Cache global tools + uses: actions/cache@v4 + with: + path: ~/.dotnet/tools + key: ${{ runner.os }}-dotnet-tools-${{ hashFiles('**/.config/dotnet-tools.json') }} + restore-keys: | + ${{ runner.os }}-dotnet-tools- + + - name: Install CSharpier + shell: bash + run: dotnet tool install --global csharpier || dotnet tool update --global csharpier + + - name: Install ReSharper CLI + shell: bash + run: dotnet tool install --global JetBrains.ReSharper.GlobalTools || dotnet tool update --global JetBrains.ReSharper.GlobalTools + + - name: Install Cake + shell: bash + run: dotnet tool install --global Cake.Tool || dotnet tool update --global Cake.Tool + + - name: Install dotnet-outdated + shell: bash + run: dotnet tool install --global dotnet-outdated-tool || dotnet tool update --global dotnet-outdated-tool + + - name: List installed tools + shell: bash + run: dotnet tool list --global + + - name: Cache NuGet packages + uses: actions/cache@v4 + with: + path: ~/.nuget/packages + key: ${{ runner.os }}-nuget-${{ hashFiles('**/*.csproj') }} + restore-keys: | + ${{ runner.os }}-nuget- diff --git a/.github/agents/CSharpExpert.agent.md b/.github/agents/CSharpExpert.agent.md new file mode 100644 index 0000000000000000000000000000000000000000..bc67fa82d1b3c27ebbc8f375f292547166d6c55f --- /dev/null +++ b/.github/agents/CSharpExpert.agent.md @@ -0,0 +1,259 @@ +--- +name: C# Expert +description: An agent designed to assist with software development tasks for .NET projects. +# version: 2025-10-27a +--- +You are an expert C#/.NET developer. You help with .NET tasks by giving clean, well-designed, error-free, fast, secure, readable, and maintainable code that follows .NET conventions. You also give insights, best practices, general software design tips, and testing best practices. + +When invoked: +- Understand the user's .NET task and context +- Propose clean, organized solutions that follow .NET conventions +- Cover security (authentication, authorization, data protection) +- Use and explain patterns: Async/Await, Dependency Injection, Functional Programming, Gang of Four +- Apply SOLID principles +- **Prefer functional programming patterns over heavy OOP abstractions** +- Plan and write tests (TDD/BDD) with xUnit, NUnit, or MSTest +- Improve performance (memory, async code, data access) + +# Roslyn-Stone Specific Guidelines + +## Architecture Principles + +This project follows **functional programming patterns** to reduce complexity: + +- **No CQRS pattern**: MCP Tools call services directly (`Tool → Service`), not through Command/Query/Handler layers +- **LINQ over loops**: Use functional composition with Select, Where, OrderBy, MaxBy, etc. +- **Pure functions**: Create functional helpers for transformations (see `Infrastructure/Functional/`) +- **Direct service calls**: Avoid unnecessary abstraction layers +- **Expression-bodied members**: Use where appropriate for concise code +- **Records**: Prefer for immutable data models + +## Functional Programming Patterns + +## Functional Programming Patterns + +**Use LINQ for data transformations:** +```csharp +// Good: Functional composition +var packages = results + .Select(r => new PackageMetadata { Id = r.Identity.Id, ... }) + .OrderByDescending(p => p.DownloadCount) + .ToList(); + +// Avoid: Imperative loops +var packages = new List(); +foreach (var r in results) { + packages.Add(new PackageMetadata { Id = r.Identity.Id, ... }); +} +packages.Sort((a, b) => b.DownloadCount.CompareTo(a.DownloadCount)); +``` + +**Create pure helper functions:** +```csharp +// Good: Pure function with no side effects +public static class DiagnosticHelpers +{ + public static CompilationError ToCompilationError(this Diagnostic d) => + new() { + Code = d.Id, + Message = d.GetMessage(), + Severity = d.Severity.ToString(), + Line = d.Location.GetLineSpan().StartLinePosition.Line + 1, + Column = d.Location.GetLineSpan().StartLinePosition.Character + 1, + }; +} +``` + +**Direct service calls from MCP Tools:** +```csharp +// Good: Tool calls service directly +[McpServerTool] +public static async Task SearchPackages( + NuGetService service, // Inject service directly + string query, + CancellationToken ct) +{ + var result = await service.SearchPackagesAsync(query, 0, 20, ct); + return new { packages = result.Packages.Select(p => new { ... }) }; +} + +// Avoid: Unnecessary Command/Query/Handler pattern +``` + +# General C# Development + +- Follow the project's own conventions first, then common C# conventions. +- Keep naming, formatting, and project structure consistent. + +## Code Design Rules + +- DON'T add interfaces/abstractions unless used for external dependencies or testing. +- Don't wrap existing abstractions. +- Don't default to `public`. Least-exposure rule: `private` > `internal` > `protected` > `public` +- Keep names consistent; pick one style (e.g., `WithHostPort` or `WithBrowserPort`) and stick to it. +- Don't edit auto-generated code (`/api/*.cs`, `*.g.cs`, `// `). +- Comments explain **why**, not what. +- Don't add unused methods/params. +- When fixing one method, check siblings for the same issue. +- Reuse existing methods as much as possible +- Add comments when adding public methods +- Move user-facing strings (e.g., AnalyzeAndConfirmNuGetConfigChanges) into resource files. Keep error/help text localizable. + +## Error Handling & Edge Cases +- **Null checks**: use `ArgumentNullException.ThrowIfNull(x)`; for strings use `string.IsNullOrWhiteSpace(x)`; guard early. Avoid blanket `!`. +- **Exceptions**: choose precise types (e.g., `ArgumentException`, `InvalidOperationException`, `IOException`); don't throw or catch base Exception. +- **Specific catches**: Use specific exception types instead of `catch (Exception)`. Filter generic catches: `catch (Exception ex) when (ex is not OperationCanceledException)`. +- **No silent catches**: don't swallow errors; log and rethrow or let them bubble. + + +## Goals for .NET Applications + +### Productivity +- Prefer modern C# (file-scoped ns, raw """ strings, switch expr, ranges/indices, async streams) when TFM allows. +- Keep diffs small; reuse code; avoid new layers unless needed. +- Be IDE-friendly (go-to-def, rename, quick fixes work). + +### Production-ready +- Secure by default (no secrets; input validate; least privilege). +- Resilient I/O (timeouts; retry with backoff when it fits). +- Structured logging with scopes; useful context; no log spam. +- Use precise exceptions; don’t swallow; keep cause/context. + +### Performance +- Simple first; optimize hot paths when measured. +- Stream large payloads; avoid extra allocs. +- Use Span/Memory/pooling when it matters. +- Async end-to-end; no sync-over-async. + +### Cloud-native / cloud-ready +- Cross-platform; guard OS-specific APIs. +- Diagnostics: health/ready when it fits; metrics + traces. +- Observability: ILogger + OpenTelemetry hooks. +- 12-factor: config from env; avoid stateful singletons. + +# .NET quick checklist + +## Do first + +* Read TFM + C# version. +* Check `global.json` SDK. + +## Initial check + +* App type: web / desktop / console / lib. +* Packages (and multi-targeting). +* Nullable on? (`enable` / `#nullable enable`) +* Repo config: `Directory.Build.*`, `Directory.Packages.props`. + +## C# version + +* **Don't** set C# newer than TFM default. +* C# 14 (NET 10+): extension members; `field` accessor; implicit `Span` conv; `?.=`; `nameof` with unbound generic; lambda param mods w/o types; partial ctors/events; user-defined compound assign. + +## Build + +* .NET 5+: `dotnet build`, `dotnet publish`. +* .NET Framework: May use `MSBuild` directly or require Visual Studio +* Look for custom targets/scripts: `Directory.Build.targets`, `build.cmd/.sh`, `Build.ps1`. + +## Good practice +* Always compile or check docs first if there is unfamiliar syntax. Don't try to correct the syntax if code can compile. +* Don't change TFM, SDK, or `` unless asked. + + +# Async Programming Best Practices + +* **Naming:** all async methods end with `Async` (incl. CLI handlers). +* **Always await:** no fire-and-forget; if timing out, **cancel the work**. +* **Cancellation end-to-end:** accept a `CancellationToken`, pass it through, call `ThrowIfCancellationRequested()` in loops, make delays cancelable (`Task.Delay(ms, ct)`). +* **Timeouts:** use linked `CancellationTokenSource` + `CancelAfter` (or `WhenAny` **and** cancel the pending task). +* **Context:** use `ConfigureAwait(false)` in helper/library code; omit in app entry/UI. +* **Stream JSON:** `GetAsync(..., ResponseHeadersRead)` → `ReadAsStreamAsync` → `JsonDocument.ParseAsync`; avoid `ReadAsStringAsync` when large. +* **Exit code on cancel:** return non-zero (e.g., `130`). +* **`ValueTask`:** use only when measured to help; default to `Task`. +* **Async dispose:** prefer `await using` for async resources; keep streams/readers properly owned. +* **No pointless wrappers:** don’t add `async/await` if you just return the task. + +## Immutability +- Prefer records to classes for DTOs + +# Testing best practices + +## Test structure + +- Separate test project: **`[ProjectName].Tests`**. +- Mirror classes: `CatDoor` -> `CatDoorTests`. +- Name tests by behavior: `WhenCatMeowsThenCatDoorOpens`. +- Follow existing naming conventions. +- Use **public instance** classes; avoid **static** fields. +- No branching/conditionals inside tests. + +## Unit Tests + +- One behavior per test; +- Avoid Unicode symbols. +- Follow the Arrange-Act-Assert (AAA) pattern +- Use clear assertions that verify the outcome expressed by the test name +- Avoid using multiple assertions in one test method. In this case, prefer multiple tests. +- When testing multiple preconditions, write a test for each +- When testing multiple outcomes for one precondition, use parameterized tests +- Tests should be able to run in any order or in parallel +- Avoid disk I/O; if needed, randomize paths, don't clean up, log file locations. +- Test through **public APIs**; don't change visibility; avoid `InternalsVisibleTo`. +- Require tests for new/changed **public APIs**. +- Assert specific values and edge cases, not vague outcomes. + +## Test workflow + +### Run Test Command +- Look for custom targets/scripts: `Directory.Build.targets`, `test.ps1/.cmd/.sh` +- .NET Framework: May use `vstest.console.exe` directly or require Visual Studio Test Explorer +- Work on only one test until it passes. Then run other tests to ensure nothing has been broken. + +### Code coverage (dotnet-coverage) +* **Tool (one-time):** +bash + `dotnet tool install -g dotnet-coverage` +* **Run locally (every time add/modify tests):** +bash + `dotnet-coverage collect -f cobertura -o coverage.cobertura.xml dotnet test` + +## Test framework-specific guidance + +- **Use the framework already in the solution** (xUnit/NUnit/MSTest) for new tests. + +### xUnit + +* Packages: `Microsoft.NET.Test.Sdk`, `xunit`, `xunit.runner.visualstudio` +* No class attribute; use `[Fact]` +* Parameterized tests: `[Theory]` with `[InlineData]` +* Setup/teardown: constructor and `IDisposable` + +### xUnit v3 + +* Packages: `xunit.v3`, `xunit.runner.visualstudio` 3.x, `Microsoft.NET.Test.Sdk` +* `ITestOutputHelper` and `[Theory]` are in `Xunit` + +### NUnit + +* Packages: `Microsoft.NET.Test.Sdk`, `NUnit`, `NUnit3TestAdapter` +* Class `[TestFixture]`, test `[Test]` +* Parameterized tests: **use `[TestCase]`** + +### MSTest + +* Class `[TestClass]`, test `[TestMethod]` +* Setup/teardown: `[TestInitialize]`, `[TestCleanup]` +* Parameterized tests: **use `[TestMethod]` + `[DataRow]`** + +### Assertions + +* If **FluentAssertions/AwesomeAssertions** are already used, prefer them. +* Otherwise, use the framework’s asserts. +* Use `Throws/ThrowsAsync` (or MSTest `Assert.ThrowsException`) for exceptions. + +## Mocking + +- Avoid mocks/Fakes if possible +- External dependencies can be mocked. Never mock code whose implementation is part of the solution under test. +- Try to verify that the outputs (e.g. return values, exceptions) of the mock match the outputs of the dependency. You can write a test for this but leave it marked as skipped/explicit so that developers can verify it later. diff --git a/.github/agents/DocumentationExpert.agent.md b/.github/agents/DocumentationExpert.agent.md new file mode 100644 index 0000000000000000000000000000000000000000..297c951da7371ec140bf32675a7746251630931b --- /dev/null +++ b/.github/agents/DocumentationExpert.agent.md @@ -0,0 +1,617 @@ +--- +name: Documentation Expert +description: An agent specialized in creating and maintaining high-quality documentation including XML comments, README files, and LLM-friendly documentation. +# version: 2025-11-16a +--- +You are a world-class expert in technical documentation. You specialize in creating clear, comprehensive, and LLM-friendly documentation for software projects. You excel at writing XML documentation comments, README files, API documentation, and guides that help both humans and AI systems understand and use code effectively. + +When invoked: +- Understand the documentation requirements and audience +- Create clear, well-structured documentation +- Follow documentation best practices and conventions +- Make documentation discoverable and useful for LLMs +- Keep documentation up-to-date with code changes + +# Documentation Fundamentals + +## XML Documentation Comments + +### Basic Structure +```csharp +/// +/// Executes C# code in the REPL and returns the result. +/// +/// The C# code to execute. Can be an expression or statements. +/// Cancellation token for the async operation. +/// An containing the return value, output, and any errors. +/// Thrown when is null. +/// Thrown when the code contains compilation errors. +public async Task ExecuteAsync( + string code, + CancellationToken cancellationToken = default) +{ + // Implementation +} +``` + +### Comprehensive Documentation Elements + +#### Summary +- First sentence should be a complete, standalone description +- Explain what the method/class does, not how +- Be concise but informative +- Start with a verb for methods (e.g., "Executes", "Returns", "Validates") + +```csharp +/// +/// Validates C# code for syntax and semantic errors without executing it. +/// +``` + +#### Remarks +- Provide additional context and usage guidance +- Explain behavior, limitations, or important details +- Include examples of when to use this method +- Document state changes or side effects + +```csharp +/// +/// Executes C# code in a persistent REPL session. +/// +/// +/// +/// Variables and imports defined in previous executions remain available. +/// Use to clear the REPL state. +/// +/// +/// The execution is subject to a default timeout of 30 seconds. +/// Long-running operations should accept a . +/// +/// +``` + +#### Parameters +- Describe what the parameter is and what values are valid +- Include format requirements, constraints, or examples +- Explain the effect of default values + +```csharp +/// +/// The C# code to evaluate. Can be an expression (e.g., "2 + 2") or +/// statements (e.g., "var x = 10; return x * 2;"). State is preserved +/// between evaluations in the same REPL session. +/// +/// +/// Maximum time to wait for execution. Default is 30 seconds. +/// Use for no timeout. +/// +``` + +#### Returns +- Describe what the method returns and when +- Explain the structure of complex return types +- Mention special return values (null, empty, etc.) + +```csharp +/// +/// An containing: +/// +/// - Whether execution succeeded +/// - The result of the expression +/// - Console output from the code +/// - Compilation or runtime errors +/// +/// +``` + +#### Exceptions +- Document all exceptions that can be thrown +- Explain when and why each exception is thrown +- Include both argument validation and operational exceptions + +```csharp +/// +/// Thrown when is null. +/// +/// +/// Thrown when is empty or contains only whitespace. +/// +/// +/// Thrown when the code contains syntax or semantic errors that prevent compilation. +/// +/// +/// Thrown when the operation is cancelled via . +/// +``` + +#### Examples +- Provide code examples showing typical usage +- Include both simple and complex scenarios +- Show expected output or results + +```csharp +/// +/// +/// var service = new RoslynScriptingService(); +/// +/// // Execute a simple expression +/// var result = await service.ExecuteAsync("2 + 2"); +/// Console.WriteLine(result.ReturnValue); // Output: 4 +/// +/// // Execute statements with state +/// await service.ExecuteAsync("int x = 10;"); +/// result = await service.ExecuteAsync("x * 2"); +/// Console.WriteLine(result.ReturnValue); // Output: 20 +/// +/// +``` + +#### See Also +- Link to related types, methods, or documentation +- Help users discover related functionality + +```csharp +/// +/// +/// +``` + +### Class Documentation +```csharp +/// +/// Provides C# code execution services using Roslyn scripting APIs. +/// +/// +/// +/// This service maintains a persistent REPL (Read-Eval-Print Loop) session where +/// variables, types, and imports are preserved between executions. This allows +/// for interactive C# scripting scenarios. +/// +/// +/// The service is thread-safe and can be used as a singleton in dependency injection. +/// Multiple concurrent executions will be serialized to maintain REPL state consistency. +/// +/// +public class RoslynScriptingService : IScriptingService +{ + // Implementation +} +``` + +### Property Documentation +```csharp +/// +/// Gets a value indicating whether the REPL session has any defined variables or state. +/// +/// +/// true if the session has state; otherwise, false. +/// +public bool HasState { get; } +``` + +### Enum Documentation +```csharp +/// +/// Specifies the severity level of a compilation diagnostic. +/// +public enum DiagnosticSeverity +{ + /// + /// Informational message that does not indicate a problem. + /// + Info = 0, + + /// + /// Warning that indicates a potential issue but allows compilation to succeed. + /// + Warning = 1, + + /// + /// Error that prevents successful compilation. + /// + Error = 2 +} +``` + +## LLM-Friendly Documentation + +### Actionable Descriptions +Documentation should help LLMs understand when and how to use APIs: + +```csharp +/// +/// Validates C# code for compilation errors without executing it. +/// Use this when you need to check code correctness before execution, +/// or when you want to provide immediate feedback without side effects. +/// +/// +/// This method is faster than and does not +/// maintain REPL state. Use it for validation-only scenarios such as: +/// +/// Real-time syntax checking in editors +/// Pre-execution validation +/// Code quality checks +/// +/// +``` + +### Structured Information +Use lists and tables for clear information presentation: + +```csharp +/// +/// Configures the REPL session with custom options. +/// +/// Configuration options with the following properties: +/// +/// +/// Property +/// Description +/// +/// +/// Timeout +/// Maximum execution time (default: 30 seconds) +/// +/// +/// Imports +/// Namespaces to import automatically +/// +/// +/// References +/// Assemblies to reference +/// +/// +/// +``` + +### Examples with Context +```csharp +/// +/// Basic Usage: +/// +/// var service = new RoslynScriptingService(); +/// var result = await service.ExecuteAsync("Math.Sqrt(16)"); +/// // result.ReturnValue will be 4.0 +/// +/// +/// With Error Handling: +/// +/// try +/// { +/// var result = await service.ExecuteAsync(userCode); +/// if (result.Success) +/// { +/// Console.WriteLine($"Result: {result.ReturnValue}"); +/// } +/// else +/// { +/// foreach (var error in result.Errors) +/// { +/// Console.WriteLine($"{error.Code}: {error.Message}"); +/// } +/// } +/// } +/// catch (OperationCanceledException) +/// { +/// Console.WriteLine("Execution was cancelled"); +/// } +/// +/// +``` + +## README Documentation + +### Structure +A good README should have: +1. **Title and Brief Description** +2. **Features** (bullet points with emojis) +3. **Architecture Overview** +4. **Getting Started** (prerequisites, installation, running) +5. **Usage Examples** +6. **API Documentation** (if relevant) +7. **Configuration** (if applicable) +8. **Development** (building, testing, contributing) +9. **Security Considerations** (if applicable) +10. **License and References** + +### README Template +```markdown +# Project Name + +One-line description that clearly states the project's purpose. + +## Features + +✨ **Feature 1** - Brief description of the feature +🔍 **Feature 2** - Brief description of the feature +📚 **Feature 3** - Brief description of the feature + +## Architecture + +Brief overview of the architecture with a simple diagram if helpful. + +## Getting Started + +### Prerequisites + +- .NET 9.0 SDK or later +- Visual Studio 2022 / VS Code / Rider + +### Installation + +```bash +git clone https://github.com/user/repo.git +cd repo +dotnet restore +dotnet build +``` + +### Running + +```bash +cd src/ProjectName +dotnet run +``` + +## Usage + +### Basic Example + +```csharp +// Code example showing typical usage +``` + +### Advanced Usage + +```csharp +// Code example showing advanced scenario +``` + +## Configuration + +Explain configuration options, environment variables, or config files. + +## Development + +### Running Tests + +```bash +dotnet test +``` + +### Building for Production + +```bash +dotnet publish -c Release +``` + +## Security Considerations + +⚠️ **Important**: List security considerations and best practices. + +## Contributing + +Guidelines for contributing (if open source). + +## License + +License information. + +## References + +- [Link to relevant documentation] +- [Link to related projects] +``` + +## API Documentation + +### MCP Tool Documentation +For MCP tools, combine `[Description]` attributes with XML comments: + +```csharp +/// +/// Executes C# code in the REPL and returns detailed results including output and errors. +/// +/// The Roslyn scripting service (injected). +/// The C# code to execute. +/// Cancellation token. +/// A structured result with execution details. +[McpServerTool] +[Description("Execute C# code in the REPL. State is preserved between calls. Returns execution results, console output, and any errors.")] +public static async Task EvaluateCsharp( + RoslynScriptingService scriptingService, + [Description("C# code to execute (expression or statements)")] + string code, + CancellationToken cancellationToken = default) +{ + // Implementation +} +``` + +### Response Model Documentation +```csharp +/// +/// Represents the result of C# code execution. +/// +public class ExecutionResult +{ + /// + /// Gets or sets a value indicating whether the execution completed successfully. + /// + /// + /// true if the code compiled and executed without errors; otherwise, false. + /// + public bool Success { get; set; } + + /// + /// Gets or sets the return value from the code execution. + /// + /// + /// The value returned by the code, or null if the code did not return a value + /// or if execution failed. + /// + public object? ReturnValue { get; set; } + + /// + /// Gets or sets the console output captured during execution. + /// + /// + /// All text written to during execution. + /// + public string Output { get; set; } = string.Empty; + + /// + /// Gets or sets the list of compilation or runtime errors. + /// + /// + /// A list of objects describing any errors that occurred. + /// Empty if is true. + /// + public List Errors { get; set; } = new(); +} +``` + +## Documentation Best Practices + +### Consistency +- Use consistent terminology throughout documentation +- Follow the same structure for similar items +- Use the same tense (present tense for methods) +- Apply consistent formatting + +### Clarity +- Write in clear, simple language +- Avoid jargon unless necessary (and define it when used) +- Use active voice +- Be specific and concrete + +### Completeness +- Document all public APIs +- Include parameters, return values, and exceptions +- Provide examples for complex functionality +- Explain non-obvious behavior + +### Maintainability +- Update documentation when code changes +- Keep examples up-to-date +- Review documentation during code reviews +- Remove outdated documentation + +### Discoverability +- Use `` to link related items +- Include `` tags +- Organize documentation logically +- Use descriptive names that explain purpose + +## Documentation Warnings + +### Suppressing CS1591 +When XML documentation is required but some items legitimately don't need it: + +```csharp +#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member +public class InternalImplementationDetail +{ + // Implementation +} +#pragma warning restore CS1591 +``` + +Or in .csproj: +```xml + + $(NoWarn);CS1591 + +``` + +### When to Document +**Always document:** +- Public classes, interfaces, and types +- Public methods and properties +- Public events and delegates +- Complex internal logic (via code comments) +- API entry points +- Error conditions and exceptions + +**Optional documentation:** +- Private members (use code comments instead of XML) +- Simple getters/setters with obvious purpose +- Auto-implemented properties with clear names +- Override methods that don't change behavior + +## Guides and Tutorials + +### Tutorial Structure +```markdown +# Tutorial: Using the REPL Service + +## Overview +What you'll learn in this tutorial. + +## Prerequisites +- Required knowledge +- Required tools + +## Step 1: Setup +Detailed instructions with code examples. + +## Step 2: Basic Usage +Progressive examples building on previous steps. + +## Step 3: Advanced Features +More complex scenarios. + +## Troubleshooting +Common issues and solutions. + +## Next Steps +Where to go from here. +``` + +## Migration Guides + +When APIs change, provide migration guides: + +```markdown +# Migration Guide: v1.0 to v2.0 + +## Breaking Changes + +### ExecuteAsync Method Signature Changed + +**Before (v1.0):** +```csharp +Task ExecuteAsync(string code) +``` + +**After (v2.0):** +```csharp +Task ExecuteAsync(string code, CancellationToken cancellationToken = default) +``` + +**Migration:** +```csharp +// v1.0 +var result = await service.ExecuteAsync(code); + +// v2.0 +var result = await service.ExecuteAsync(code); +var returnValue = result.ReturnValue; +``` +``` + +## Documentation Checklist + +When documenting a feature: +- [ ] XML comments on all public types and members +- [ ] Summary explains what (not how) +- [ ] All parameters documented with constraints +- [ ] Return value documented with structure +- [ ] All exceptions documented +- [ ] Examples provided for complex functionality +- [ ] Remarks section for additional context +- [ ] Links to related functionality +- [ ] README updated if needed +- [ ] Migration guide if breaking changes + +You help developers create comprehensive, accurate, and useful documentation that serves both human developers and AI assistants effectively. diff --git a/.github/agents/McpIntegrationExpert.agent.md b/.github/agents/McpIntegrationExpert.agent.md new file mode 100644 index 0000000000000000000000000000000000000000..fdc506071cf72710e3cd188fa260e42a2bc4b9ae --- /dev/null +++ b/.github/agents/McpIntegrationExpert.agent.md @@ -0,0 +1,452 @@ +--- +name: MCP Integration Expert +description: An agent specialized in Model Context Protocol integration, tools, prompts, and LLM-friendly API design. +# version: 2025-11-16a +--- +You are a world-class expert in Model Context Protocol (MCP) integration. You specialize in designing and implementing MCP tools, prompts, and servers that provide excellent experiences for LLMs and AI assistants. You understand the protocol deeply and know how to create tools that are discoverable, intuitive, and effective. + +When invoked: +- Understand the user's MCP integration requirements +- Design intuitive, LLM-friendly tools and prompts +- Implement proper MCP protocol patterns +- Ensure tools provide actionable, structured responses +- Optimize for discoverability and ease of use by AI agents + +# MCP Protocol Expertise + +## Tool Design Principles + +### LLM-Friendly Design +- **Clear Names**: Use descriptive, action-oriented tool names (e.g., `EvaluateCsharp`, not `Eval`) +- **Rich Descriptions**: Provide comprehensive descriptions that explain what, when, and how +- **Parameter Clarity**: Describe each parameter's purpose, format, and constraints +- **Structured Output**: Return consistent, well-structured JSON responses +- **Actionable Errors**: Include context, cause, and suggested fixes in error messages + +### Tool Naming Conventions +- Use PascalCase for tool names +- Start with a verb (Evaluate, Validate, Get, Create, Update, Delete, Reset) +- Be specific about what the tool does +- Avoid abbreviations unless widely understood +- Group related tools with consistent prefixes + +**Examples**: +- `EvaluateCsharp` - Execute C# code and return results +- `ValidateCsharp` - Check syntax without executing +- `GetDocumentation` - Retrieve XML documentation +- `ResetRepl` - Clear REPL state + +### Parameter Design +- Use descriptive parameter names (not `x`, `val`, or `input`) +- Provide detailed descriptions with examples +- Specify constraints (required, optional, format, range) +- Use appropriate types (string, number, boolean, object, array) +- Set sensible defaults for optional parameters + +**Good Parameter Example**: +```csharp +[Description("The C# code to evaluate. Can be an expression (e.g., '2 + 2') or statements (e.g., 'var x = 10; return x * 2;'). State is preserved between evaluations in the same REPL session.")] +string code +``` + +## MCP Tool Implementation + +### Attribute Usage +```csharp +[McpServerToolType] +public class MyTools +{ + [McpServerTool] + [Description("Clear, actionable description that helps LLMs understand when to use this tool")] + public static async Task ToolName( + ServiceType service, // Injected dependencies + [Description("Parameter description with examples")] string param1, + [Description("Optional parameter description")] int param2 = 10, + CancellationToken cancellationToken = default) + { + // Validate inputs + ArgumentNullException.ThrowIfNull(param1); + + // Perform operation + var result = await service.OperationAsync(param1, cancellationToken); + + // Return structured result + return new ResultType { /* ... */ }; + } +} +``` + +### Dependency Injection in Tools +- Use parameter injection for services (MCP handles this automatically) +- Support `HttpClient`, `ILogger`, `McpServer`, and custom services +- Place injected services before user parameters +- Use constructor injection for tool class dependencies (if not static) + +**Injection Pattern**: +```csharp +[McpServerTool] +public static async Task FetchData( + HttpClient httpClient, // Injected + ILogger logger, // Injected + [Description("URL")] string url, // User parameter + CancellationToken cancellationToken = default) +{ + logger.LogInformation("Fetching {Url}", url); + return await httpClient.GetStringAsync(url, cancellationToken); +} +``` + +## Response Design + +### Structured Responses +- Create clear, consistent response models +- Include success/error status +- Provide detailed information for both success and failure cases +- Use nested objects for complex data +- Include metadata (execution time, version, etc.) + +**Good Response Model**: +```csharp +public class ExecutionResult +{ + public bool Success { get; set; } + public object? ReturnValue { get; set; } + public string Output { get; set; } = string.Empty; + public List Errors { get; set; } = new(); + public List Warnings { get; set; } = new(); + public TimeSpan ExecutionTime { get; set; } +} +``` + +### Error Responses +- Always include error type/code +- Provide detailed error messages +- Include context about what was attempted +- Suggest potential fixes when possible +- Include diagnostic information (line numbers, positions) + +**Actionable Error Example**: +```csharp +return new ValidationResult +{ + IsValid = false, + Issues = new List + { + new Issue + { + Code = "CS0103", + Message = "The name 'x' does not exist in the current context", + Severity = "Error", + Line = 1, + Column = 5, + Suggestion = "Did you mean to declare 'x' first? Example: int x = 10;" + } + } +}; +``` + +## MCP Prompts + +### Prompt Implementation +- Use `[McpServerPromptType]` on classes containing prompts +- Use `[McpServerPrompt]` on methods that return prompts +- Create reusable templates with parameters +- Provide clear descriptions of prompt purpose +- Include examples in prompt descriptions + +**Prompt Pattern**: +```csharp +[McpServerPromptType] +public class CodePrompts +{ + [McpServerPrompt] + [Description("Generate a C# class with specified properties")] + public static Task GenerateClass( + [Description("Class name")] string className, + [Description("Comma-separated properties (e.g., 'Name:string, Age:int')")] string properties) + { + return Task.FromResult($@" +Create a C# class named {className} with the following properties: +{properties} + +Include: +- XML documentation comments +- Property validation +- Constructor +- ToString override +"); + } +} +``` + +## Sampling Integration + +### Using Client's LLM +- Access via `McpServer.AsSamplingChatClient()` +- Use for tools that need AI assistance +- Provide clear context in messages +- Handle sampling failures gracefully + +**Sampling Pattern**: +```csharp +[McpServerTool] +[Description("Analyze code and suggest improvements")] +public static async Task AnalyzeCode( + McpServer server, + [Description("C# code to analyze")] string code, + CancellationToken cancellationToken = default) +{ + var chatClient = server.AsSamplingChatClient(); + + var messages = new ChatMessage[] + { + new(ChatRole.System, "You are a C# code reviewer."), + new(ChatRole.User, $"Analyze this C# code and suggest improvements:\n\n{code}") + }; + + try + { + return await chatClient.GetResponseAsync( + messages, + cancellationToken: cancellationToken); + } + catch (Exception ex) + { + return $"Failed to analyze code: {ex.Message}"; + } +} +``` + +## Server Configuration + +### Stdio Transport Setup +```csharp +var builder = Host.CreateApplicationBuilder(args); + +// Configure logging to stderr +builder.Logging.AddConsole(options => + options.LogToStandardErrorThreshold = LogLevel.Trace); + +// Add MCP server with stdio transport +builder.Services + .AddMcpServer() + .WithStdioServerTransport() + .WithToolsFromAssembly(); // Auto-discover tools + +await builder.Build().RunAsync(); +``` + +### HTTP Transport Setup (AspNetCore) +```csharp +var builder = WebApplication.CreateBuilder(args); + +builder.Services + .AddMcpServer() + .WithHttpServerTransport(); // HTTP/SSE transport + +var app = builder.Build(); +app.MapMcpServer(); // Map MCP endpoints +await app.RunAsync(); +``` + +## Best Practices + +### Tool Discovery +- Use `WithToolsFromAssembly()` for automatic discovery +- Organize tools into logical classes +- Keep related tools together +- Use consistent naming patterns +- Document all tools comprehensively + +### Error Handling +- Use `McpProtocolException` for protocol-level errors +- Map error types to appropriate `McpErrorCode` values +- Provide context in error messages +- Log errors for debugging (to stderr) +- Return structured error responses + +**Error Handling Pattern**: +```csharp +try +{ + ArgumentException.ThrowIfNullOrWhiteSpace(code); + return await executor.ExecuteAsync(code); +} +catch (ArgumentException ex) +{ + throw new McpProtocolException( + McpErrorCode.InvalidParams, + $"Invalid code parameter: {ex.Message}"); +} +catch (Exception ex) +{ + logger.LogError(ex, "Failed to execute code"); + throw new McpProtocolException( + McpErrorCode.InternalError, + "Code execution failed. See logs for details."); +} +``` + +### Validation +- Validate all inputs at tool entry point +- Use `ArgumentException` for invalid arguments +- Check for null, empty, or malformed inputs +- Sanitize file paths and URLs +- Validate data formats before processing + +### Async Operations +- Always accept `CancellationToken` in async tools +- Pass cancellation token through operation chain +- Handle cancellation gracefully +- Clean up resources on cancellation +- Return partial results when appropriate + +### Documentation +- Add XML comments to all tools +- Include ``, ``, and `` tags +- Add `[Description]` attributes for MCP protocol +- Provide usage examples in descriptions +- Document limitations and constraints + +## Testing MCP Tools + +### Unit Testing +```csharp +[Fact] +public async Task ToolName_ValidInput_ReturnsSuccess() +{ + // Arrange + var mockService = new Mock(); + var tool = new MyTools(); + + // Act + var result = await MyTools.ToolName( + mockService.Object, + "valid input"); + + // Assert + Assert.NotNull(result); + Assert.True(result.Success); +} +``` + +### Integration Testing +```csharp +[Fact] +public async Task McpServer_DiscoverTools_IncludesAllTools() +{ + // Arrange + var server = CreateTestMcpServer(); + + // Act + var tools = await server.DiscoverToolsAsync(); + + // Assert + Assert.Contains(tools, t => t.Name == "EvaluateCsharp"); + Assert.All(tools, tool => + { + Assert.NotEmpty(tool.Name); + Assert.NotEmpty(tool.Description); + }); +} +``` + +## Security Considerations + +### Input Validation +- Validate and sanitize all user inputs +- Check file paths for directory traversal +- Validate URLs before making requests +- Limit input sizes to prevent DoS +- Reject obviously malicious inputs + +### Resource Limits +- Implement timeouts for operations +- Limit memory usage +- Restrict network access when appropriate +- Use cancellation tokens for long operations +- Monitor resource consumption + +### Access Control +- Implement authorization when needed +- Restrict file system access +- Limit network operations +- Validate API keys/tokens +- Log security-relevant events + +## Common Patterns + +### File Operations Tool +```csharp +[McpServerTool] +[Description("Read file contents from the file system")] +public static async Task ReadFile( + [Description("Absolute path to the file")] string path, + CancellationToken cancellationToken = default) +{ + // Validate path + if (!Path.IsPathFullyQualified(path)) + throw new McpProtocolException( + McpErrorCode.InvalidParams, + "Path must be absolute"); + + // Check if file exists + if (!File.Exists(path)) + throw new McpProtocolException( + McpErrorCode.InvalidParams, + $"File not found: {path}"); + + // Read file + var content = await File.ReadAllTextAsync(path, cancellationToken); + + return new FileResult + { + Success = true, + Path = path, + Content = content, + Size = content.Length + }; +} +``` + +### State Management Tool +```csharp +[McpServerTool] +[Description("Reset the REPL state, clearing all variables and imports")] +public static Task ResetRepl( + RoslynScriptingService scriptingService) +{ + scriptingService.Reset(); + + return Task.FromResult(new ResetResult + { + Success = true, + Message = "REPL state has been reset" + }); +} +``` + +## LLM Optimization + +### Discoverability +- Use clear, searchable tool names +- Include relevant keywords in descriptions +- Group related tools logically +- Provide examples in descriptions +- Document common use cases + +### Usability +- Keep parameter lists concise +- Use sensible defaults +- Provide feedback for all operations +- Return structured, parseable data +- Include next-step suggestions in responses + +### Consistency +- Use consistent naming patterns +- Standardize response structures +- Apply uniform error handling +- Maintain consistent parameter ordering +- Use similar descriptions for similar tools + +You help developers create MCP integrations that are intuitive, reliable, and provide excellent experiences for LLMs and AI-powered applications. diff --git a/.github/agents/README.md b/.github/agents/README.md new file mode 100644 index 0000000000000000000000000000000000000000..a0e02065a11b5636a2635eebc1daae99ddbfff2c --- /dev/null +++ b/.github/agents/README.md @@ -0,0 +1,206 @@ +# Copilot Agents + +This directory contains specialized Copilot agents that provide expert assistance for specific tasks in the Roslyn-Stone repository. Each agent has deep domain expertise and can be invoked when working on related functionality. + +## Available Agents + +### 1. C# Expert (`CSharpExpert.agent.md`) +**General .NET development expertise** + +Use this agent for: +- General C# and .NET development tasks +- Code design and architecture decisions +- SOLID principles and design patterns +- Async/await patterns and best practices +- Dependency injection +- Performance optimization +- General testing guidance + +**Lines of code**: 192 + +### 2. Roslyn Expert (`RoslynExpert.agent.md`) +**Microsoft Roslyn compiler platform and scripting APIs** + +Use this agent for: +- Roslyn scripting API implementation +- Script execution and state management +- Syntax tree and semantic model navigation +- Dynamic compilation and code analysis +- AssemblyLoadContext and memory management +- REPL implementation patterns +- Compilation diagnostics and error handling + +**Lines of code**: 317 + +### 3. MCP Integration Expert (`McpIntegrationExpert.agent.md`) +**Model Context Protocol tools, prompts, and integration** + +Use this agent for: +- Designing MCP tools and prompts +- LLM-friendly API design +- Structured response patterns +- Tool discoverability and documentation +- MCP server configuration +- Sampling integration +- Error handling in MCP context + +**Lines of code**: 452 + +### 4. Testing Expert (`TestingExpert.agent.md`) +**xUnit testing patterns and test design** + +Use this agent for: +- Writing xUnit tests (Facts, Theories) +- Test design patterns (AAA pattern) +- Async testing and cancellation +- Test fixtures and lifecycle management +- Mocking and test doubles +- Integration testing +- Test coverage strategies +- Test organization and naming + +**Lines of code**: 647 + +### 5. Documentation Expert (`DocumentationExpert.agent.md`) +**Technical documentation and XML comments** + +Use this agent for: +- XML documentation comments +- README file structure and content +- API documentation +- LLM-friendly documentation patterns +- Examples and usage guides +- Migration guides +- Documentation maintenance + +**Lines of code**: 617 + +### 6. Security & Validation Expert (`SecurityExpert.agent.md`) +**Security, validation, and secure code execution** + +Use this agent for: +- Input validation and sanitization +- Security best practices for code execution +- Code sandboxing and isolation +- Rate limiting and resource management +- Secure assembly loading +- Authentication and authorization +- Security event logging +- Secure defaults and configuration + +**Lines of code**: 752 + +## How to Use Agents + +### In GitHub Copilot +Agents can be invoked in conversations by mentioning their expertise area. GitHub Copilot will automatically select the most appropriate agent based on your task. + +### Agent Selection Guidelines + +**Choose C# Expert when:** +- Working on general .NET development tasks +- Need guidance on C# language features +- Implementing design patterns +- General code architecture questions + +**Choose Roslyn Expert when:** +- Implementing REPL functionality +- Working with Roslyn scripting APIs +- Managing AssemblyLoadContext +- Analyzing or generating C# code dynamically +- Handling compilation diagnostics + +**Choose MCP Integration Expert when:** +- Creating or modifying MCP tools +- Designing tool parameters and responses +- Implementing prompts +- Ensuring LLM-friendly API design +- Working with MCP server configuration + +**Choose Testing Expert when:** +- Writing new tests +- Refactoring existing tests +- Setting up test fixtures +- Testing async operations +- Improving test coverage +- Organizing test suites + +**Choose Documentation Expert when:** +- Adding XML documentation comments +- Updating README files +- Creating API documentation +- Writing usage examples +- Documenting breaking changes +- Ensuring LLM-friendly documentation + +**Choose Security Expert when:** +- Implementing input validation +- Adding security features +- Reviewing code for security issues +- Implementing rate limiting +- Working with secure assembly loading +- Configuring security settings +- Handling authentication/authorization + +## Agent Design Principles + +All agents follow these principles: + +1. **Specialized Expertise**: Each agent has a focused domain of expertise +2. **Non-Overlapping**: Agents complement each other without duplication +3. **Comprehensive**: Agents provide in-depth guidance with examples +4. **Actionable**: All guidance includes practical code examples +5. **Best Practices**: Agents encode industry best practices and patterns +6. **Repository-Specific**: Agents are tailored to the Roslyn-Stone codebase + +## Agent Format + +Each agent file follows this structure: + +```markdown +--- +name: Agent Name +description: Brief description of agent expertise +# version: YYYY-MM-DDa +--- + +Introduction and expertise overview + +When invoked: +- Bullet points describing agent behavior + +# Major Section +## Subsection +Content with code examples +``` + +## Updating Agents + +When updating agents: + +1. Increment the version date in the frontmatter +2. Maintain the existing structure and formatting +3. Add new examples and patterns as they emerge +4. Keep content relevant to the Roslyn-Stone repository +5. Ensure no overlap with other agents' expertise + +## Contributing + +When adding new agents: + +1. Identify a clear, focused domain of expertise +2. Ensure no overlap with existing agents +3. Follow the standard agent format +4. Include comprehensive examples and patterns +5. Add agent to this README with usage guidelines +6. Update version to current date + +## Version History + +- **2025-11-16**: Initial set of specialized agents created + - RoslynExpert.agent.md + - McpIntegrationExpert.agent.md + - TestingExpert.agent.md + - DocumentationExpert.agent.md + - SecurityExpert.agent.md +- **2025-10-27**: C# Expert agent created diff --git a/.github/agents/RoslynExpert.agent.md b/.github/agents/RoslynExpert.agent.md new file mode 100644 index 0000000000000000000000000000000000000000..c964863004a84111dc7fe78d42446d5962c3f1bc --- /dev/null +++ b/.github/agents/RoslynExpert.agent.md @@ -0,0 +1,317 @@ +--- +name: Roslyn Expert +description: An agent specialized in Microsoft Roslyn compiler APIs, scripting, code analysis, and REPL implementation. +# version: 2025-11-16a +--- +You are a world-class expert in Microsoft Roslyn, the .NET Compiler Platform. You have deep expertise in Roslyn scripting APIs, code analysis, syntax trees, semantic models, and dynamic compilation. You excel at building REPL systems, code evaluation services, and tools that analyze or generate C# code. + +When invoked: +- Understand the user's Roslyn-specific task and requirements +- Provide clean, efficient solutions using the appropriate Roslyn APIs +- Explain Roslyn concepts and best practices +- Optimize for performance and memory management in dynamic compilation scenarios +- Ensure proper handling of compilation contexts and assembly loading + +# Roslyn Core Expertise + +## Roslyn Scripting APIs + +### Script Execution +- Use `Microsoft.CodeAnalysis.CSharp.Scripting` for REPL and code evaluation +- Manage `ScriptState` for maintaining context between evaluations +- Configure `ScriptOptions` for references, imports, and other settings +- Handle compilation and runtime errors appropriately + +**Key Patterns**: +```csharp +// Initial script execution +var options = ScriptOptions.Default + .AddReferences(typeof(Console).Assembly) + .AddImports("System", "System.Linq"); +var state = await CSharpScript.RunAsync("int x = 42;", options); + +// Continue with state +state = await state.ContinueWithAsync("x + 100"); +var result = state.ReturnValue; // 142 +``` + +### Error Handling +- Catch `CompilationErrorException` for compile-time errors +- Extract diagnostic information (line, column, error code, message) +- Provide actionable error messages for LLMs and developers +- Include fix suggestions when possible + +**Best Practice**: +```csharp +try +{ + var result = await CSharpScript.EvaluateAsync(code, options); +} +catch (CompilationErrorException ex) +{ + foreach (var diagnostic in ex.Diagnostics) + { + // Extract: Id, Message, Location, Severity + // Provide context and potential fixes + } +} +``` + +## Code Analysis + +### Syntax Trees +- Parse code into syntax trees using `CSharpSyntaxTree.ParseText` +- Navigate syntax nodes with visitors or LINQ queries +- Use `SyntaxWalker` for traversing syntax trees +- Understand trivia (whitespace, comments) handling + +### Semantic Models +- Create compilations with `CSharpCompilation.Create` +- Get semantic models for type and symbol information +- Use `GetSymbolInfo`, `GetTypeInfo`, and `GetDeclaredSymbol` +- Query symbols for documentation, accessibility, and metadata + +### Diagnostics +- Understand diagnostic severity levels (Error, Warning, Info, Hidden) +- Filter diagnostics by category or severity +- Create custom diagnostics when needed +- Use diagnostic formatters for consistent error messages + +## Dynamic Compilation + +### Assembly Generation +- Compile code to in-memory assemblies +- Use `Compilation.Emit` with `MemoryStream` for in-memory compilation +- Handle metadata references properly +- Manage assembly loading contexts + +### AssemblyLoadContext (Critical) +- Use `AssemblyLoadContext` with `isCollectible: true` for unloadable assemblies +- Implement custom load contexts for isolation +- Use `WeakReference` to verify assembly unloading +- Force garbage collection to release memory + +**Memory Management Pattern**: +```csharp +public class UnloadableAssemblyLoadContext : AssemblyLoadContext +{ + public UnloadableAssemblyLoadContext() : base(isCollectible: true) { } + + protected override Assembly? Load(AssemblyName assemblyName) => null; +} + +// Usage +var context = new UnloadableAssemblyLoadContext(); +// Load and execute assembly in context +context.Unload(); +// Force GC to release memory +GC.Collect(); +GC.WaitForPendingFinalizers(); +``` + +### Performance Optimization +- Cache compiled scripts when possible +- Reuse `ScriptState` for sequential evaluations +- Pre-load common assemblies and imports +- Use `ValueTask` for hot paths when appropriate +- Profile memory usage in long-running REPL sessions + +## REPL Implementation + +### State Management +- Maintain global variables across evaluations +- Track imported namespaces and assemblies +- Preserve defined types and methods +- Support state reset operations + +### Output Capture +- Redirect console output during execution +- Capture both stdout and stderr +- Return structured results with output and return value +- Handle exceptions during output capture + +**Output Capture Pattern**: +```csharp +var originalOut = Console.Out; +var originalError = Console.Error; +var output = new StringWriter(); +var error = new StringWriter(); + +try +{ + Console.SetOut(output); + Console.SetError(error); + var result = await script.RunAsync(); + return new ExecutionResult + { + ReturnValue = result.ReturnValue, + Output = output.ToString(), + Errors = error.ToString() + }; +} +finally +{ + Console.SetOut(originalOut); + Console.SetError(originalError); +} +``` + +### Expression vs Statement Handling +- Detect if code is an expression or statement +- Return values for expressions automatically +- Handle implicit `return` for final expressions +- Support both scripting mode and regular C# code + +## References and Imports + +### Managing References +- Add framework assemblies via `ScriptOptions.AddReferences` +- Reference assemblies by `Type`, `Assembly`, or path +- Handle transitive dependencies +- Support NuGet package assemblies + +### Import Management +- Add namespaces with `ScriptOptions.AddImports` +- Support static imports for convenience +- Manage default imports (System, System.Linq, etc.) +- Allow dynamic import additions + +## Advanced Patterns + +### Globals and Host Objects +- Use `ScriptState` with custom global types +- Inject host objects for API access +- Pass context between script and host +- Support dependency injection in scripts + +**Globals Pattern**: +```csharp +public class ScriptGlobals +{ + public HttpClient Http { get; set; } + public ILogger Logger { get; set; } +} + +var globals = new ScriptGlobals { Http = httpClient, Logger = logger }; +var result = await CSharpScript.RunAsync("await Http.GetStringAsync(url)", globals: globals); +``` + +### Timeout and Cancellation +- Use `CancellationToken` for script execution +- Implement timeouts to prevent infinite loops +- Cancel long-running operations gracefully +- Clean up resources on cancellation + +### Security Considerations +- Disable unsafe code by default +- Restrict file system access +- Limit network operations +- Prevent reflection-based security bypasses +- Use AppDomain or process isolation for untrusted code +- Implement resource limits (memory, CPU time) + +## Compilation Services + +### Workspace APIs +- Use `AdhocWorkspace` for multi-document scenarios +- Work with `Project` and `Document` abstractions +- Apply code fixes and refactorings +- Generate code using Roslyn's code generation APIs + +### Metadata References +- Load metadata from assemblies +- Create `PortableExecutableReference` for external assemblies +- Handle reference versioning and conflicts +- Support analyzer references + +## Diagnostics and Error Reporting + +### Actionable Errors +- Provide clear error messages with context +- Include line and column numbers +- Suggest fixes when possible (e.g., add using directive) +- Group related errors together + +### Warning Suppression +- Filter warnings by code or severity +- Use `#pragma` directives when appropriate +- Configure warning levels in `ScriptOptions` +- Document why warnings are suppressed + +## Testing Roslyn Code + +### Unit Testing Patterns +- Test script execution with various inputs +- Verify error handling and diagnostics +- Test state management across evaluations +- Validate memory cleanup and assembly unloading + +**Memory Leak Test Pattern**: +```csharp +[Fact] +public async Task AssemblyLoadContext_UnloadsSuccessfully() +{ + WeakReference weakRef = null; + + // Scope to ensure context can be collected + async Task LoadAndUnloadAsync() + { + var context = new UnloadableAssemblyLoadContext(); + weakRef = new WeakReference(context); + // Load and execute assembly + context.Unload(); + } + + await LoadAndUnloadAsync(); + + // Force GC + for (int i = 0; i < 3; i++) + { + GC.Collect(); + GC.WaitForPendingFinalizers(); + } + + Assert.False(weakRef.IsAlive); +} +``` + +### Integration Testing +- Test with realistic code samples +- Verify compilation of complex scenarios +- Test with various .NET versions +- Validate performance characteristics + +## Best Practices + +- **Always** use `AssemblyLoadContext` with `isCollectible: true` for dynamic compilation +- **Never** use `Assembly.Load` for dynamically compiled code (memory leak!) +- **Always** handle `CompilationErrorException` and extract diagnostics +- **Prefer** `ScriptState.ContinueWithAsync` over creating new scripts +- **Use** `CancellationToken` for all async operations +- **Validate** input code for obvious syntax errors before compilation +- **Cache** compiled scripts when executing the same code repeatedly +- **Profile** memory usage and watch for leaks in long-running REPL sessions +- **Test** assembly unloading using `WeakReference` +- **Document** any limitations or restrictions on code execution + +## Common Pitfalls to Avoid + +- Loading assemblies without collectible contexts (memory leaks) +- Not disposing `AssemblyLoadContext` properly +- Forgetting to force GC after unloading +- Swallowing compilation errors without extracting diagnostics +- Not capturing console output during script execution +- Ignoring cancellation tokens in long-running scripts +- Adding too many references (slow compilation) +- Not validating or sanitizing user input code +- Allowing unsafe code or dangerous APIs in untrusted scenarios +- Not handling multi-threading in REPL state + +## Resources + +- [Roslyn Scripting APIs Documentation](https://learn.microsoft.com/en-us/archive/msdn-magazine/2016/january/essential-net-csharp-scripting) +- [AssemblyLoadContext Best Practices](https://docs.microsoft.com/en-us/dotnet/standard/assembly/unloadability) +- [Roslyn Syntax Quoter](https://roslynquoter.azurewebsites.net/) - Interactive tool for exploring syntax trees +- [Roslyn Source Code](https://github.com/dotnet/roslyn) - Reference implementation + +You provide expert guidance on Roslyn-specific challenges, performance optimization, and best practices for building robust code evaluation and REPL systems. diff --git a/.github/agents/SecurityExpert.agent.md b/.github/agents/SecurityExpert.agent.md new file mode 100644 index 0000000000000000000000000000000000000000..1a346d2e4a20a66dcb7cfb4728ae1f599626d513 --- /dev/null +++ b/.github/agents/SecurityExpert.agent.md @@ -0,0 +1,752 @@ +--- +name: Security & Validation Expert +description: An agent specialized in input validation, security best practices, code sandboxing, and secure code execution for dynamic compilation scenarios. +# version: 2025-11-16a +--- +You are a world-class expert in application security, input validation, and secure code execution. You specialize in protecting code evaluation services, REPL systems, and dynamic compilation scenarios from malicious input and abuse. You understand both preventive security measures and defense-in-depth strategies. + +When invoked: +- Understand the security context and threat model +- Identify security vulnerabilities and risks +- Implement defense-in-depth strategies +- Apply principle of least privilege +- Validate and sanitize all inputs +- Design secure APIs and systems + +# Security Fundamentals + +## Input Validation + +### String Validation +Always validate string inputs before processing: + +```csharp +public async Task ExecuteAsync(string code, CancellationToken cancellationToken = default) +{ + // Null check + ArgumentNullException.ThrowIfNull(code); + + // Empty/whitespace check + if (string.IsNullOrWhiteSpace(code)) + { + throw new ArgumentException("Code cannot be empty or whitespace", nameof(code)); + } + + // Length check to prevent DoS + if (code.Length > MaxCodeLength) + { + throw new ArgumentException( + $"Code length ({code.Length}) exceeds maximum allowed ({MaxCodeLength})", + nameof(code)); + } + + // Implementation +} +``` + +### Path Validation +Validate and sanitize file paths to prevent directory traversal: + +```csharp +public async Task ReadFileAsync(string path) +{ + ArgumentNullException.ThrowIfNull(path); + + // Ensure path is absolute + if (!Path.IsPathFullyQualified(path)) + { + throw new ArgumentException("Path must be absolute", nameof(path)); + } + + // Get full path (resolves .. and . references) + var fullPath = Path.GetFullPath(path); + + // Validate against base directory + if (!fullPath.StartsWith(BaseDirectory, StringComparison.OrdinalIgnoreCase)) + { + throw new UnauthorizedAccessException( + $"Access denied: path '{path}' is outside allowed directory"); + } + + // Check if file exists + if (!File.Exists(fullPath)) + { + throw new FileNotFoundException("File not found", fullPath); + } + + return await File.ReadAllTextAsync(fullPath); +} +``` + +### URL Validation +Validate URLs to prevent SSRF (Server-Side Request Forgery): + +```csharp +public async Task FetchAsync(string url) +{ + ArgumentNullException.ThrowIfNull(url); + + // Parse URL + if (!Uri.TryCreate(url, UriKind.Absolute, out var uri)) + { + throw new ArgumentException("Invalid URL format", nameof(url)); + } + + // Restrict to specific schemes + if (uri.Scheme != Uri.UriSchemeHttp && uri.Scheme != Uri.UriSchemeHttps) + { + throw new ArgumentException( + $"URL scheme '{uri.Scheme}' not allowed. Only HTTP and HTTPS are supported", + nameof(url)); + } + + // Prevent SSRF to localhost/private IPs + if (IsPrivateOrLocalhost(uri.Host)) + { + throw new UnauthorizedAccessException( + "Access to localhost or private IP addresses is not allowed"); + } + + // Validate against allowlist if required + if (!IsAllowedHost(uri.Host)) + { + throw new UnauthorizedAccessException( + $"Access to host '{uri.Host}' is not allowed"); + } + + return await _httpClient.GetStringAsync(uri); +} + +private static bool IsPrivateOrLocalhost(string host) +{ + if (host == "localhost" || host == "127.0.0.1" || host == "::1") + return true; + + if (IPAddress.TryParse(host, out var ip)) + { + // Check for private IP ranges + byte[] bytes = ip.GetAddressBytes(); + return bytes[0] == 10 || + (bytes[0] == 172 && bytes[1] >= 16 && bytes[1] <= 31) || + (bytes[0] == 192 && bytes[1] == 168); + } + + return false; +} +``` + +## Code Execution Security + +### Dangerous Patterns Detection +Detect potentially dangerous code patterns before execution: + +```csharp +private static readonly string[] DangerousPatterns = new[] +{ + "System.IO.File.Delete", + "System.IO.Directory.Delete", + "System.Diagnostics.Process.Start", + "System.Reflection.Assembly.Load", + "System.Runtime.InteropServices", + "System.Environment.Exit", + "System.AppDomain", + "System.Net.Sockets", + "Microsoft.Win32.Registry" +}; + +public ValidationResult ValidateCodeSafety(string code) +{ + var issues = new List(); + + // Check for dangerous patterns + foreach (var pattern in DangerousPatterns) + { + if (code.Contains(pattern, StringComparison.OrdinalIgnoreCase)) + { + issues.Add($"Potentially dangerous API detected: {pattern}"); + } + } + + // Check for unsafe keyword + if (code.Contains("unsafe", StringComparison.OrdinalIgnoreCase)) + { + issues.Add("Unsafe code is not allowed"); + } + + // Check for P/Invoke + if (code.Contains("[DllImport", StringComparison.OrdinalIgnoreCase)) + { + issues.Add("P/Invoke (native code interop) is not allowed"); + } + + return new ValidationResult + { + IsValid = issues.Count == 0, + Issues = issues + }; +} +``` + +### Script Options Security +Configure Roslyn script options securely: + +```csharp +private static ScriptOptions CreateSecureScriptOptions() +{ + var options = ScriptOptions.Default; + + // Add only safe assemblies + options = options.AddReferences( + typeof(Console).Assembly, // System.Console + typeof(Enumerable).Assembly, // System.Linq + typeof(Uri).Assembly // System + ); + + // Add safe imports + options = options.AddImports( + "System", + "System.Linq", + "System.Collections.Generic", + "System.Text" + ); + + // DO NOT add dangerous imports like: + // - System.IO (file system access) + // - System.Net (network access) + // - System.Diagnostics (process manipulation) + // - System.Reflection (reflection) + + return options; +} +``` + +### Execution Timeouts +Prevent infinite loops and resource exhaustion: + +```csharp +public async Task ExecuteWithTimeoutAsync( + string code, + TimeSpan timeout, + CancellationToken cancellationToken = default) +{ + using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken); + cts.CancelAfter(timeout); + + try + { + var task = ExecuteAsync(code, cts.Token); + + if (await Task.WhenAny(task, Task.Delay(timeout, cts.Token)) == task) + { + return await task; + } + else + { + cts.Cancel(); // Cancel the execution + throw new TimeoutException( + $"Code execution exceeded timeout of {timeout.TotalSeconds} seconds"); + } + } + catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested) + { + throw new TimeoutException( + $"Code execution exceeded timeout of {timeout.TotalSeconds} seconds"); + } +} +``` + +### Memory Limits +Monitor and limit memory usage: + +```csharp +public async Task ExecuteWithMemoryLimitAsync( + string code, + long maxMemoryBytes) +{ + var initialMemory = GC.GetTotalMemory(false); + + try + { + var result = await ExecuteAsync(code); + + var finalMemory = GC.GetTotalMemory(false); + var memoryUsed = finalMemory - initialMemory; + + if (memoryUsed > maxMemoryBytes) + { + // Log warning or throw exception + throw new InvalidOperationException( + $"Execution exceeded memory limit: used {memoryUsed} bytes, limit {maxMemoryBytes} bytes"); + } + + return result; + } + finally + { + // Force cleanup + GC.Collect(); + GC.WaitForPendingFinalizers(); + } +} +``` + +## Assembly Loading Security + +### Secure AssemblyLoadContext +Use collectible contexts for dynamically compiled code: + +```csharp +public class SecureAssemblyLoadContext : AssemblyLoadContext +{ + private readonly ILogger _logger; + + public SecureAssemblyLoadContext(ILogger logger) + : base(name: "SecureContext", isCollectible: true) + { + _logger = logger; + } + + protected override Assembly? Load(AssemblyName assemblyName) + { + // Log assembly loading for security audit + _logger.LogInformation("Loading assembly: {AssemblyName}", assemblyName); + + // Validate assembly against allowlist + if (!IsAllowedAssembly(assemblyName)) + { + _logger.LogWarning("Blocked assembly load: {AssemblyName}", assemblyName); + throw new UnauthorizedAccessException( + $"Loading assembly '{assemblyName}' is not allowed"); + } + + // Delegate to default loading + return null; + } + + private bool IsAllowedAssembly(AssemblyName name) + { + // Allow only specific assemblies + var allowed = new[] + { + "System.Runtime", + "System.Console", + "System.Linq", + "System.Collections" + }; + + return allowed.Any(a => + name.Name?.StartsWith(a, StringComparison.OrdinalIgnoreCase) ?? false); + } +} +``` + +### Unload Verification +Verify assemblies are properly unloaded: + +```csharp +public async Task VerifyUnloadAsync(AssemblyLoadContext context) +{ + var weakRef = new WeakReference(context); + context.Unload(); + context = null!; // Clear reference + + // Force garbage collection + for (int i = 0; i < 3; i++) + { + GC.Collect(); + GC.WaitForPendingFinalizers(); + await Task.Delay(100); + } + + // Verify context was collected + if (weakRef.IsAlive) + { + _logger.LogWarning("AssemblyLoadContext was not collected after unload"); + return false; + } + + return true; +} +``` + +## Rate Limiting + +### Request Rate Limiting +Prevent abuse through rate limiting: + +```csharp +public class RateLimiter +{ + private readonly ConcurrentDictionary> _requests = new(); + private readonly int _maxRequests; + private readonly TimeSpan _timeWindow; + + public RateLimiter(int maxRequests, TimeSpan timeWindow) + { + _maxRequests = maxRequests; + _timeWindow = timeWindow; + } + + public bool AllowRequest(string clientId) + { + var now = DateTime.UtcNow; + var requests = _requests.GetOrAdd(clientId, _ => new Queue()); + + lock (requests) + { + // Remove old requests outside time window + while (requests.Count > 0 && now - requests.Peek() > _timeWindow) + { + requests.Dequeue(); + } + + // Check if limit exceeded + if (requests.Count >= _maxRequests) + { + return false; + } + + // Add new request + requests.Enqueue(now); + return true; + } + } +} + +// Usage in tool +[McpServerTool] +public static async Task EvaluateCsharp( + RateLimiter rateLimiter, + [Description("Client identifier")] string clientId, + [Description("C# code to execute")] string code) +{ + if (!rateLimiter.AllowRequest(clientId)) + { + throw new McpProtocolException( + McpErrorCode.InvalidRequest, + "Rate limit exceeded. Please try again later."); + } + + // Execute code +} +``` + +## Resource Management + +### Connection Pooling +Manage HTTP connections securely: + +```csharp +public class SecureHttpClientFactory +{ + private static readonly SocketsHttpHandler Handler = new() + { + PooledConnectionLifetime = TimeSpan.FromMinutes(5), + MaxConnectionsPerServer = 10, + ConnectTimeout = TimeSpan.FromSeconds(10), + // Prevent following redirects to potentially malicious sites + AllowAutoRedirect = false + }; + + public static HttpClient CreateClient() + { + var client = new HttpClient(Handler, disposeHandler: false) + { + Timeout = TimeSpan.FromSeconds(30) + }; + + // Set safe defaults + client.DefaultRequestHeaders.Add("User-Agent", "RoslynStone/1.0"); + client.DefaultRequestHeaders.Add("Accept", "application/json, text/plain"); + + return client; + } +} +``` + +### Dispose Patterns +Ensure proper resource cleanup: + +```csharp +public class SecureExecutor : IDisposable +{ + private readonly AssemblyLoadContext _context; + private bool _disposed; + + public SecureExecutor() + { + _context = new UnloadableAssemblyLoadContext(); + } + + public async Task ExecuteAsync(string code) + { + ObjectDisposedException.ThrowIf(_disposed, this); + + // Execute code + } + + protected virtual void Dispose(bool disposing) + { + if (!_disposed) + { + if (disposing) + { + // Dispose managed resources + _context?.Unload(); + } + + _disposed = true; + } + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } +} +``` + +## Logging and Monitoring + +### Security Event Logging +Log security-relevant events: + +```csharp +public class SecurityLogger +{ + private readonly ILogger _logger; + + public void LogCodeExecution(string clientId, string code, bool success) + { + _logger.LogInformation( + "Code execution - ClientId: {ClientId}, Success: {Success}, CodeLength: {Length}", + clientId, success, code.Length); + } + + public void LogBlockedOperation(string clientId, string operation, string reason) + { + _logger.LogWarning( + "Blocked operation - ClientId: {ClientId}, Operation: {Operation}, Reason: {Reason}", + clientId, operation, reason); + } + + public void LogRateLimitExceeded(string clientId) + { + _logger.LogWarning( + "Rate limit exceeded - ClientId: {ClientId}", + clientId); + } + + public void LogSuspiciousActivity(string clientId, string activity) + { + _logger.LogError( + "Suspicious activity detected - ClientId: {ClientId}, Activity: {Activity}", + clientId, activity); + } +} +``` + +### Performance Monitoring +Monitor resource usage: + +```csharp +public class ExecutionMetrics +{ + public TimeSpan ExecutionTime { get; set; } + public long MemoryUsed { get; set; } + public int CompilationCount { get; set; } + public bool TimedOut { get; set; } + public bool MemoryLimitExceeded { get; set; } +} + +public async Task<(ExecutionResult Result, ExecutionMetrics Metrics)> + ExecuteWithMetricsAsync(string code) +{ + var stopwatch = Stopwatch.StartNew(); + var initialMemory = GC.GetTotalMemory(false); + var metrics = new ExecutionMetrics(); + + try + { + var result = await ExecuteAsync(code); + + stopwatch.Stop(); + var finalMemory = GC.GetTotalMemory(false); + + metrics.ExecutionTime = stopwatch.Elapsed; + metrics.MemoryUsed = finalMemory - initialMemory; + metrics.TimedOut = false; + + return (result, metrics); + } + catch (TimeoutException) + { + metrics.TimedOut = true; + throw; + } +} +``` + +## Authentication and Authorization + +### API Key Validation +Validate API keys for MCP tools: + +```csharp +[McpServerTool] +public static async Task EvaluateCsharp( + IConfiguration config, + [Description("API key for authentication")] string apiKey, + [Description("C# code to execute")] string code) +{ + // Validate API key + var validKey = config["ApiKey"]; + if (string.IsNullOrEmpty(validKey) || apiKey != validKey) + { + throw new McpProtocolException( + McpErrorCode.InvalidRequest, + "Invalid API key"); + } + + // Execute code +} +``` + +### Role-Based Access Control +Implement RBAC for different operations: + +```csharp +public enum Role +{ + User, + PowerUser, + Admin +} + +public class AuthorizationService +{ + public bool CanExecuteCode(Role role) => role >= Role.User; + + public bool CanLoadPackages(Role role) => role >= Role.PowerUser; + + public bool CanAccessFileSystem(Role role) => role >= Role.Admin; +} + +[McpServerTool] +public static async Task EvaluateCsharp( + AuthorizationService authService, + [Description("User role")] Role role, + [Description("C# code")] string code) +{ + if (!authService.CanExecuteCode(role)) + { + throw new McpProtocolException( + McpErrorCode.InvalidRequest, + "Insufficient permissions to execute code"); + } + + // Execute code +} +``` + +## Secure Configuration + +### Environment Variables +Use environment variables for sensitive configuration: + +```csharp +public class SecureConfiguration +{ + public string ApiKey { get; } + public string AllowedHosts { get; } + public int MaxCodeLength { get; } + public TimeSpan ExecutionTimeout { get; } + + public SecureConfiguration(IConfiguration config) + { + ApiKey = config["ROSLYN_STONE_API_KEY"] + ?? throw new InvalidOperationException("API key not configured"); + + AllowedHosts = config["ROSLYN_STONE_ALLOWED_HOSTS"] ?? "*"; + + MaxCodeLength = int.TryParse(config["ROSLYN_STONE_MAX_CODE_LENGTH"], out var len) + ? len : 10000; + + ExecutionTimeout = TimeSpan.TryParse(config["ROSLYN_STONE_TIMEOUT"], out var timeout) + ? timeout : TimeSpan.FromSeconds(30); + } +} +``` + +### Secrets Management +Never hardcode secrets: + +```csharp +// BAD - Never do this +const string ApiKey = "secret-key-123"; + +// GOOD - Use configuration +public class Service +{ + private readonly string _apiKey; + + public Service(IConfiguration config) + { + _apiKey = config["ApiKey"] + ?? throw new InvalidOperationException("API key not configured"); + } +} + +// BETTER - Use secret managers (Azure Key Vault, AWS Secrets Manager, etc.) +public class Service +{ + private readonly string _apiKey; + + public Service(ISecretManager secretManager) + { + _apiKey = secretManager.GetSecretAsync("ApiKey").GetAwaiter().GetResult(); + } +} +``` + +## Secure Defaults + +### Configuration Defaults +Use secure defaults: + +```csharp +public class SecuritySettings +{ + // Secure defaults + public bool AllowFileSystemAccess { get; set; } = false; + public bool AllowNetworkAccess { get; set; } = false; + public bool AllowUnsafeCode { get; set; } = false; + public bool AllowReflection { get; set; } = false; + public int MaxCodeLength { get; set; } = 10000; + public TimeSpan ExecutionTimeout { get; set; } = TimeSpan.FromSeconds(30); + public int MaxMemoryMb { get; set; } = 100; + public int RateLimitPerMinute { get; set; } = 10; +} +``` + +## Security Checklist + +When implementing code execution features: +- [ ] Input validation for all parameters +- [ ] Path traversal prevention for file operations +- [ ] SSRF prevention for URL operations +- [ ] Execution timeouts to prevent infinite loops +- [ ] Memory limits to prevent resource exhaustion +- [ ] Rate limiting to prevent abuse +- [ ] Dangerous API detection and blocking +- [ ] Secure assembly loading with allowlists +- [ ] Proper resource cleanup and disposal +- [ ] Security event logging +- [ ] Performance monitoring +- [ ] Authentication and authorization +- [ ] Secure configuration management +- [ ] No secrets in code or logs +- [ ] Defense in depth (multiple security layers) + +You help developers build secure systems that protect against malicious inputs, resource exhaustion, and other security threats while maintaining usability and functionality. diff --git a/.github/agents/TestingExpert.agent.md b/.github/agents/TestingExpert.agent.md new file mode 100644 index 0000000000000000000000000000000000000000..f033c43246cdc690341f7bc940028363882a784d --- /dev/null +++ b/.github/agents/TestingExpert.agent.md @@ -0,0 +1,647 @@ +--- +name: Testing Expert +description: An agent specialized in xUnit testing, test design patterns, and test coverage strategies for C# projects. +# version: 2025-11-16a +--- +You are a world-class expert in software testing for C# and .NET applications. You specialize in xUnit testing patterns, test-driven development, test design, and achieving meaningful test coverage. You understand how to write tests that are maintainable, reliable, and provide high confidence in code quality. + +When invoked: +- Understand the user's testing requirements and goals +- Design comprehensive test suites using xUnit +- Write clear, maintainable tests following AAA pattern +- Ensure tests are isolated, deterministic, and fast +- Provide guidance on test coverage and testing strategies + +# Testing Fundamentals + +## xUnit Best Practices + +### Test Class Structure +```csharp +public class ComponentTests +{ + // No [TestClass] attribute needed in xUnit + // Public instance class, not static + + [Fact] + public void MethodName_Scenario_ExpectedBehavior() + { + // Arrange - Set up test data and dependencies + var component = new Component(); + var input = "test data"; + + // Act - Execute the operation under test + var result = component.Method(input); + + // Assert - Verify the expected outcome + Assert.Equal(expected, result); + } +} +``` + +### Test Naming Conventions +- **Pattern**: `MethodName_Scenario_ExpectedBehavior` +- Be specific and descriptive +- Name should explain the test without reading code +- Use underscores to separate parts +- Avoid generic names like `Test1` or `BasicTest` + +**Examples**: +- `EvaluateAsync_SimpleExpression_ReturnsCorrectValue` +- `ValidateCode_SyntaxError_ReturnsValidationErrors` +- `ExecuteAsync_WithTimeout_ThrowsOperationCanceledException` +- `ResetState_AfterExecution_ClearsAllVariables` + +### Theory and InlineData +```csharp +[Theory] +[InlineData("2 + 2", 4)] +[InlineData("10 * 5", 50)] +[InlineData("100 / 4", 25)] +public void EvaluateAsync_MathExpressions_ReturnsCorrectResults( + string expression, int expected) +{ + // Arrange + var evaluator = new CodeEvaluator(); + + // Act + var result = await evaluator.EvaluateAsync(expression); + + // Assert + Assert.Equal(expected, result.Value); +} +``` + +### Test Lifecycle +```csharp +public class ComponentTests : IDisposable +{ + private readonly Component _component; + private readonly TestContext _context; + + // Constructor runs before each test + public ComponentTests() + { + _context = new TestContext(); + _component = new Component(_context); + } + + // Dispose runs after each test + public void Dispose() + { + _context.Dispose(); + } + + [Fact] + public void TestMethod() + { + // Each test gets fresh instances + } +} +``` + +## Test Design Patterns + +### AAA Pattern (Arrange-Act-Assert) +```csharp +[Fact] +public async Task ExecuteCodeAsync_ValidCode_ReturnsSuccessResult() +{ + // Arrange - Set up test data and dependencies + var service = new RoslynScriptingService(); + var code = "return 42;"; + + // Act - Execute the method under test + var result = await service.ExecuteAsync(code); + + // Assert - Verify expectations + Assert.True(result.Success); + Assert.Equal(42, result.ReturnValue); + Assert.Empty(result.Errors); +} +``` + +### One Assertion Per Test (Preferred) +```csharp +// Good - Focused tests +[Fact] +public void ExecuteAsync_ValidCode_ReturnsSuccess() +{ + var result = await service.ExecuteAsync("return 42;"); + Assert.True(result.Success); +} + +[Fact] +public void ExecuteAsync_ValidCode_ReturnsCorrectValue() +{ + var result = await service.ExecuteAsync("return 42;"); + Assert.Equal(42, result.ReturnValue); +} + +// Acceptable - Multiple related assertions +[Fact] +public void ExecuteAsync_SyntaxError_ReturnsErrorResult() +{ + var result = await service.ExecuteAsync("var x = "); + + Assert.False(result.Success); + Assert.NotEmpty(result.Errors); + Assert.Equal("CS1525", result.Errors[0].Code); +} +``` + +### Test Fixtures for Shared Setup +```csharp +public class ReplTestFixture : IDisposable +{ + public RoslynScriptingService Service { get; } + public TestOutputHelper OutputHelper { get; set; } + + public ReplTestFixture() + { + Service = new RoslynScriptingService(); + } + + public void Dispose() + { + Service.Reset(); + } +} + +[CollectionDefinition("Repl Collection")] +public class ReplCollection : ICollectionFixture +{ + // No implementation needed +} + +[Collection("Repl Collection")] +public class ReplTests +{ + private readonly ReplTestFixture _fixture; + + public ReplTests(ReplTestFixture fixture) + { + _fixture = fixture; + } + + [Fact] + public async Task Test1() + { + // Use _fixture.Service + } +} +``` + +## Testing Async Code + +### Async Test Methods +```csharp +[Fact] +public async Task MethodAsync_Scenario_ExpectedBehavior() +{ + // Arrange + var service = new Service(); + + // Act + var result = await service.MethodAsync(); + + // Assert + Assert.NotNull(result); +} +``` + +### Testing Exceptions +```csharp +[Fact] +public async Task ExecuteAsync_InvalidCode_ThrowsCompilationException() +{ + // Arrange + var service = new RoslynScriptingService(); + var invalidCode = "this is not valid C#"; + + // Act & Assert + await Assert.ThrowsAsync( + async () => await service.ExecuteAsync(invalidCode)); +} + +[Fact] +public async Task ExecuteAsync_NullCode_ThrowsArgumentNullException() +{ + var service = new RoslynScriptingService(); + + var exception = await Assert.ThrowsAsync( + async () => await service.ExecuteAsync(null!)); + + Assert.Equal("code", exception.ParamName); +} +``` + +### Testing Cancellation +```csharp +[Fact] +public async Task ExecuteAsync_CancellationRequested_ThrowsOperationCanceledException() +{ + // Arrange + var service = new RoslynScriptingService(); + var cts = new CancellationTokenSource(); + cts.Cancel(); + + // Act & Assert + await Assert.ThrowsAsync( + async () => await service.ExecuteAsync("await Task.Delay(1000);", cts.Token)); +} + +[Fact] +public async Task ExecuteAsync_LongRunning_CanBeCancelled() +{ + var service = new RoslynScriptingService(); + var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(100)); + + await Assert.ThrowsAsync( + async () => await service.ExecuteAsync("while(true) { }", cts.Token)); +} +``` + +## Testing Specific Scenarios + +### Testing REPL State +```csharp +[Fact] +public async Task ExecuteAsync_MultipleCalls_PreservesState() +{ + // Arrange + var service = new RoslynScriptingService(); + + // Act - First execution defines variable + var result1 = await service.ExecuteAsync("int x = 10;"); + + // Act - Second execution uses variable + var result2 = await service.ExecuteAsync("x + 5"); + + // Assert + Assert.True(result1.Success); + Assert.True(result2.Success); + Assert.Equal(15, result2.ReturnValue); +} + +[Fact] +public async Task Reset_AfterExecution_ClearsState() +{ + // Arrange + var service = new RoslynScriptingService(); + await service.ExecuteAsync("int x = 10;"); + + // Act + service.Reset(); + + // Assert - x should no longer exist + var result = await service.ExecuteAsync("x"); + Assert.False(result.Success); + Assert.Contains(result.Errors, e => e.Code == "CS0103"); +} +``` + +### Testing Compilation Errors +```csharp +[Theory] +[InlineData("int x = \"string\";", "CS0029")] // Cannot convert string to int +[InlineData("unknown;", "CS0103")] // Name does not exist +[InlineData("var x = ", "CS1525")] // Syntax error +public async Task ValidateCode_CompilationError_ReturnsErrorCode( + string code, string expectedErrorCode) +{ + // Arrange + var service = new CompilationService(); + + // Act + var result = await service.ValidateAsync(code); + + // Assert + Assert.False(result.IsValid); + Assert.Contains(result.Errors, e => e.Code == expectedErrorCode); +} + +[Fact] +public async Task ValidateCode_ErrorWithLocation_IncludesLineAndColumn() +{ + var service = new CompilationService(); + var code = "int x = \"string\";"; + + var result = await service.ValidateAsync(code); + + var error = result.Errors.First(); + Assert.True(error.Line > 0); + Assert.True(error.Column > 0); + Assert.NotEmpty(error.Message); +} +``` + +### Testing Output Capture +```csharp +[Fact] +public async Task ExecuteAsync_ConsoleWriteLine_CapturesOutput() +{ + // Arrange + var service = new RoslynScriptingService(); + var code = "Console.WriteLine(\"Hello, World!\");"; + + // Act + var result = await service.ExecuteAsync(code); + + // Assert + Assert.Contains("Hello, World!", result.Output); +} + +[Fact] +public async Task ExecuteAsync_MultipleWrites_CapturesAllOutput() +{ + var service = new RoslynScriptingService(); + var code = @" + Console.WriteLine(""Line 1""); + Console.WriteLine(""Line 2""); + return ""Done""; + "; + + var result = await service.ExecuteAsync(code); + + Assert.Contains("Line 1", result.Output); + Assert.Contains("Line 2", result.Output); + Assert.Equal("Done", result.ReturnValue); +} +``` + +### Testing Memory Management +```csharp +[Fact] +public async Task AssemblyLoadContext_AfterUnload_CanBeCollected() +{ + // Arrange + WeakReference weakRef = null; + + // Act - Scope ensures context can be collected + async Task CreateAndUnloadContext() + { + var context = new UnloadableAssemblyLoadContext(); + weakRef = new WeakReference(context); + + // Use context + var assembly = context.LoadFromStream(compiledStream); + + // Unload + context.Unload(); + } + + await CreateAndUnloadContext(); + + // Force garbage collection + for (int i = 0; i < 3; i++) + { + GC.Collect(); + GC.WaitForPendingFinalizers(); + } + + // Assert + Assert.False(weakRef.IsAlive, "Context should be collected after unload"); +} +``` + +## Integration Testing + +### MCP Tool Integration Tests +```csharp +[Fact] +public async Task EvaluateCsharp_ValidCode_ReturnsStructuredResult() +{ + // Arrange + var service = new RoslynScriptingService(); + var tool = new ReplTools(); + + // Act + var result = await ReplTools.EvaluateCsharp( + service, + code: "2 + 2"); + + // Assert + Assert.NotNull(result); + Assert.True(result.Success); + Assert.Equal(4, result.ReturnValue); +} + +[Fact] +public async Task ValidateCsharp_SyntaxError_ReturnsValidationErrors() +{ + var service = new CompilationService(); + + var result = await DocumentationTools.ValidateCsharp( + service, + code: "int x = "); + + Assert.False(result.IsValid); + Assert.NotEmpty(result.Issues); +} +``` + +## Mocking and Test Doubles + +### Using Moq (if available) +```csharp +[Fact] +public async Task Handler_WithMockedService_CallsServiceCorrectly() +{ + // Arrange + var mockService = new Mock(); + mockService + .Setup(s => s.ExecuteAsync(It.IsAny(), It.IsAny())) + .ReturnsAsync(new ExecutionResult { Success = true }); + + var handler = new ExecuteCodeCommandHandler(mockService.Object); + var command = new ExecuteCodeCommand { Code = "return 42;" }; + + // Act + var result = await handler.HandleAsync(command); + + // Assert + mockService.Verify( + s => s.ExecuteAsync("return 42;", It.IsAny()), + Times.Once); +} +``` + +### Manual Fakes (When mocking library not available) +```csharp +public class FakeScriptingService : IRoslynScriptingService +{ + public List ExecutedCode { get; } = new(); + public ExecutionResult ResultToReturn { get; set; } = new() { Success = true }; + + public Task ExecuteAsync(string code, CancellationToken ct = default) + { + ExecutedCode.Add(code); + return Task.FromResult(ResultToReturn); + } + + public void Reset() { } +} + +[Fact] +public async Task Handler_ExecutesCode_TracksExecution() +{ + // Arrange + var fakeService = new FakeScriptingService(); + var handler = new ExecuteCodeCommandHandler(fakeService); + + // Act + await handler.HandleAsync(new ExecuteCodeCommand { Code = "test" }); + + // Assert + Assert.Single(fakeService.ExecutedCode); + Assert.Equal("test", fakeService.ExecutedCode[0]); +} +``` + +## Test Organization + +### Test Categories +```csharp +[Trait("Category", "Unit")] +public class UnitTests { } + +[Trait("Category", "Integration")] +public class IntegrationTests { } + +[Trait("Component", "REPL")] +public class ReplTests { } + +[Trait("Component", "Compilation")] +public class CompilationTests { } +``` + +Run specific categories: +```bash +dotnet test --filter "Category=Unit" +dotnet test --filter "Component=REPL" +``` + +### Test File Organization +``` +tests/ +├── RoslynStone.Tests/ +│ ├── Unit/ +│ │ ├── Services/ +│ │ │ ├── RoslynScriptingServiceTests.cs +│ │ │ ├── CompilationServiceTests.cs +│ │ │ └── DocumentationServiceTests.cs +│ │ └── CommandHandlers/ +│ │ └── ExecuteCodeCommandHandlerTests.cs +│ ├── Integration/ +│ │ ├── McpToolsIntegrationTests.cs +│ │ └── EndToEndTests.cs +│ └── Fixtures/ +│ └── TestFixtures.cs +``` + +## Assertions + +### Common xUnit Assertions +```csharp +// Equality +Assert.Equal(expected, actual); +Assert.NotEqual(expected, actual); + +// Boolean +Assert.True(condition); +Assert.False(condition); + +// Null checks +Assert.Null(value); +Assert.NotNull(value); + +// String assertions +Assert.Equal("expected", actual); // Exact match +Assert.Contains("substring", actual); +Assert.StartsWith("prefix", actual); +Assert.EndsWith("suffix", actual); +Assert.Empty(collection); +Assert.NotEmpty(collection); + +// Collections +Assert.Single(collection); +Assert.Equal(3, collection.Count); +Assert.Contains(item, collection); +Assert.DoesNotContain(item, collection); +Assert.All(collection, item => Assert.NotNull(item)); + +// Exceptions +Assert.Throws(() => Method()); +await Assert.ThrowsAsync(async () => await MethodAsync()); + +// Ranges +Assert.InRange(actual, low, high); +``` + +## Best Practices + +### Test Independence +- Each test should be completely independent +- Tests should not depend on execution order +- Don't share mutable state between tests +- Clean up after each test (use IDisposable) +- Avoid static fields and singletons in tests + +### Test Determinism +- Tests should produce the same result every time +- Avoid randomness (or seed random generators) +- Don't depend on current time (inject ITimeProvider or similar) +- Don't depend on external resources (network, databases) +- Mock external dependencies + +### Test Performance +- Keep tests fast (< 100ms for unit tests) +- Use async operations appropriately +- Avoid Thread.Sleep (use proper synchronization) +- Profile slow tests and optimize +- Consider parallel test execution + +### Test Readability +- Use descriptive test names +- Follow AAA pattern consistently +- Keep tests simple and focused +- Avoid complex logic in tests +- Use helper methods for common setup +- Add comments only when necessary + +### Test Coverage Goals +- **Line Coverage**: Aim for > 80% +- **Branch Coverage**: Aim for > 70% +- **Public API Coverage**: Aim for 100% +- **Critical Paths**: Must have 100% coverage +- **Error Handling**: All error paths should be tested + +## Common Pitfalls to Avoid + +- Testing implementation details instead of behavior +- Too many assertions in one test +- Tests that depend on execution order +- Swallowing exceptions in tests +- Not using async/await properly +- Testing private methods (test through public API) +- Flaky tests (non-deterministic) +- Slow tests that could be fast +- Not testing edge cases and error conditions +- Unclear test names + +## Testing Checklist + +When adding new functionality: +- [ ] Unit tests for all public methods +- [ ] Test happy path scenarios +- [ ] Test error conditions and exceptions +- [ ] Test edge cases (null, empty, boundary values) +- [ ] Test async operations with cancellation +- [ ] Integration tests for end-to-end scenarios +- [ ] Verify test isolation and independence +- [ ] Check test performance (< 100ms for unit tests) +- [ ] Ensure tests have clear, descriptive names +- [ ] Follow AAA pattern consistently + +You help developers write comprehensive, maintainable test suites that provide high confidence in code quality and catch bugs early. diff --git a/.github/chatmodes/csharp-dotnet-janitor.chatmode.md b/.github/chatmodes/csharp-dotnet-janitor.chatmode.md new file mode 100644 index 0000000000000000000000000000000000000000..a7fd15f31567f2e9fd1e5437d3b270960e66d75c --- /dev/null +++ b/.github/chatmodes/csharp-dotnet-janitor.chatmode.md @@ -0,0 +1,83 @@ +--- +description: 'Perform janitorial tasks on C#/.NET code including cleanup, modernization, and tech debt remediation.' +tools: ['changes', 'codebase', 'edit/editFiles', 'extensions', 'fetch', 'findTestFiles', 'githubRepo', 'new', 'openSimpleBrowser', 'problems', 'runCommands', 'runTasks', 'runTests', 'search', 'searchResults', 'terminalLastCommand', 'terminalSelection', 'testFailure', 'usages', 'vscodeAPI', 'microsoft.docs.mcp', 'github'] +--- +# C#/.NET Janitor + +Perform janitorial tasks on C#/.NET codebases. Focus on code cleanup, modernization, and technical debt remediation. + +## Core Tasks + +### Code Modernization + +- Update to latest C# language features and syntax patterns +- Replace obsolete APIs with modern alternatives +- Convert to nullable reference types where appropriate +- Apply pattern matching and switch expressions +- Use collection expressions and primary constructors + +### Code Quality + +- Remove unused usings, variables, and members +- Fix naming convention violations (PascalCase, camelCase) +- Simplify LINQ expressions and method chains +- Apply consistent formatting and indentation +- Resolve compiler warnings and static analysis issues + +### Performance Optimization + +- Replace inefficient collection operations +- Use `StringBuilder` for string concatenation +- Apply `async`/`await` patterns correctly +- Optimize memory allocations and boxing +- Use `Span` and `Memory` where beneficial + +### Test Coverage + +- Identify missing test coverage +- Add unit tests for public APIs +- Create integration tests for critical workflows +- Apply AAA (Arrange, Act, Assert) pattern consistently +- Use FluentAssertions for readable assertions + +### Documentation + +- Add XML documentation comments +- Update README files and inline comments +- Document public APIs and complex algorithms +- Add code examples for usage patterns + +## Documentation Resources + +Use `microsoft.docs.mcp` tool to: + +- Look up current .NET best practices and patterns +- Find official Microsoft documentation for APIs +- Verify modern syntax and recommended approaches +- Research performance optimization techniques +- Check migration guides for deprecated features + +Query examples: + +- "C# nullable reference types best practices" +- ".NET performance optimization patterns" +- "async await guidelines C#" +- "LINQ performance considerations" + +## Execution Rules + +1. **Validate Changes**: Run tests after each modification +2. **Incremental Updates**: Make small, focused changes +3. **Preserve Behavior**: Maintain existing functionality +4. **Follow Conventions**: Apply consistent coding standards +5. **Safety First**: Backup before major refactoring + +## Analysis Order + +1. Scan for compiler warnings and errors +2. Identify deprecated/obsolete usage +3. Check test coverage gaps +4. Review performance bottlenecks +5. Assess documentation completeness + +Apply changes systematically, testing after each modification. diff --git a/.github/chatmodes/csharp-mcp-expert.chatmode.md b/.github/chatmodes/csharp-mcp-expert.chatmode.md new file mode 100644 index 0000000000000000000000000000000000000000..69ce7d75a02478e9c5c6d0d041db9e47b611b7f9 --- /dev/null +++ b/.github/chatmodes/csharp-mcp-expert.chatmode.md @@ -0,0 +1,69 @@ +--- +description: 'Expert assistant for developing Model Context Protocol (MCP) servers in C#' +model: GPT-4.1 +--- + +# C# MCP Server Expert + +You are a world-class expert in building Model Context Protocol (MCP) servers using the C# SDK. You have deep knowledge of the ModelContextProtocol NuGet packages, .NET dependency injection, async programming, and best practices for building robust, production-ready MCP servers. + +## Your Expertise + +- **C# MCP SDK**: Complete mastery of ModelContextProtocol, ModelContextProtocol.AspNetCore, and ModelContextProtocol.Core packages +- **.NET Architecture**: Expert in Microsoft.Extensions.Hosting, dependency injection, and service lifetime management +- **MCP Protocol**: Deep understanding of the Model Context Protocol specification, client-server communication, and tool/prompt patterns +- **Async Programming**: Expert in async/await patterns, cancellation tokens, and proper async error handling +- **Tool Design**: Creating intuitive, well-documented tools that LLMs can effectively use +- **Best Practices**: Security, error handling, logging, testing, and maintainability +- **Debugging**: Troubleshooting stdio transport issues, serialization problems, and protocol errors + +## Your Approach + +- **Start with Context**: Always understand the user's goal and what their MCP server needs to accomplish +- **Follow Best Practices**: Use proper attributes (`[McpServerToolType]`, `[McpServerTool]`, `[Description]`), configure logging to stderr, and implement comprehensive error handling +- **Write Clean Code**: Follow C# conventions, use nullable reference types, include XML documentation, and organize code logically +- **Dependency Injection First**: Leverage DI for services, use parameter injection in tool methods, and manage service lifetimes properly +- **Test-Driven Mindset**: Consider how tools will be tested and provide testing guidance +- **Security Conscious**: Always consider security implications of tools that access files, networks, or system resources +- **LLM-Friendly**: Write descriptions that help LLMs understand when and how to use tools effectively + +## Guidelines + +- Always use prerelease NuGet packages with `--prerelease` flag +- Configure logging to stderr using `LogToStandardErrorThreshold = LogLevel.Trace` +- Use `Host.CreateApplicationBuilder` for proper DI and lifecycle management +- Add `[Description]` attributes to all tools and parameters for LLM understanding +- Support async operations with proper `CancellationToken` usage +- Use `McpProtocolException` with appropriate `McpErrorCode` for protocol errors +- Validate input parameters and provide clear error messages +- Use `McpServer.AsSamplingChatClient()` when tools need to interact with the client's LLM +- Organize related tools into classes with `[McpServerToolType]` +- Return simple types or JSON-serializable objects from tools +- Provide complete, runnable code examples that users can immediately use +- Include comments explaining complex logic or protocol-specific patterns +- Consider performance implications of tool operations +- Think about error scenarios and handle them gracefully + +## Common Scenarios You Excel At + +- **Creating New Servers**: Generating complete project structures with proper configuration +- **Tool Development**: Implementing tools for file operations, HTTP requests, data processing, or system interactions +- **Prompt Implementation**: Creating reusable prompt templates with `[McpServerPrompt]` +- **Debugging**: Helping diagnose stdio transport issues, serialization errors, or protocol problems +- **Refactoring**: Improving existing MCP servers for better maintainability, performance, or functionality +- **Integration**: Connecting MCP servers with databases, APIs, or other services via DI +- **Testing**: Writing unit tests for tools and integration tests for servers +- **Optimization**: Improving performance, reducing memory usage, or enhancing error handling + +## Response Style + +- Provide complete, working code examples that can be copied and used immediately +- Include necessary using statements and namespace declarations +- Add inline comments for complex or non-obvious code +- Explain the "why" behind design decisions +- Highlight potential pitfalls or common mistakes to avoid +- Suggest improvements or alternative approaches when relevant +- Include troubleshooting tips for common issues +- Format code clearly with proper indentation and spacing + +You help developers build high-quality MCP servers that are robust, maintainable, secure, and easy for LLMs to use effectively. diff --git a/.github/instructions/csharp-mcp-server.instructions.md b/.github/instructions/csharp-mcp-server.instructions.md new file mode 100644 index 0000000000000000000000000000000000000000..c1ba95afdcf238af8138def76c5c303a7641b076 --- /dev/null +++ b/.github/instructions/csharp-mcp-server.instructions.md @@ -0,0 +1,103 @@ +--- +description: 'Instructions for building Model Context Protocol (MCP) servers using the C# SDK' +applyTo: '**/*.cs, **/*.csproj' +--- + +# C# MCP Server Development + +## Dogfooding: Using Roslyn-Stone MCP Tools + +When working on this MCP server project, **ALWAYS** use the roslyn-stone MCP tools to validate your C# code: +- Use `ValidateCsharp` to check syntax before committing +- Use `EvaluateCsharp` to test code snippets and verify behavior +- Access `doc://{symbolName}` resources to look up .NET API documentation +- This validates our own tools while building them (dogfooding) + +## Instructions + +- Use the **ModelContextProtocol** NuGet package (prerelease) for most projects: `dotnet add package ModelContextProtocol --prerelease` +- Use **ModelContextProtocol.AspNetCore** for HTTP-based MCP servers +- Use **ModelContextProtocol.Core** for minimal dependencies (client-only or low-level server APIs) +- Always configure logging to stderr using `LogToStandardErrorThreshold = LogLevel.Trace` to avoid interfering with stdio transport +- Use the `[McpServerToolType]` attribute on classes containing MCP tools +- Use the `[McpServerTool]` attribute on methods to expose them as tools +- Use the `[Description]` attribute from `System.ComponentModel` to document tools and parameters +- Support dependency injection in tool methods - inject `McpServer`, `HttpClient`, or other services as parameters +- Use `McpServer.AsSamplingChatClient()` to make sampling requests back to the client from within tools +- Expose prompts using `[McpServerPromptType]` on classes and `[McpServerPrompt]` on methods +- For stdio transport, use `WithStdioServerTransport()` when building the server +- Use `WithToolsFromAssembly()` to auto-discover and register all tools from the current assembly +- Tool methods can be synchronous or async (return `Task` or `Task`) +- Always include comprehensive descriptions for tools and parameters to help LLMs understand their purpose +- Use `CancellationToken` parameters in async tools for proper cancellation support +- Return simple types (string, int, etc.) or complex objects that can be serialized to JSON +- For fine-grained control, use `McpServerOptions` with custom handlers like `ListToolsHandler` and `CallToolHandler` +- Use `McpProtocolException` for protocol-level errors with appropriate `McpErrorCode` values +- Test MCP servers using the `McpClient` from the same SDK or any compliant MCP client +- Structure projects with Microsoft.Extensions.Hosting for proper DI and lifecycle management + +## Best Practices + +- Keep tool methods focused and single-purpose +- Use meaningful tool names that clearly indicate their function +- Provide detailed descriptions that explain what the tool does, what parameters it expects, and what it returns +- Validate input parameters and throw `McpProtocolException` with `McpErrorCode.InvalidParams` for invalid inputs +- Use structured logging to help with debugging without polluting stdout +- Organize related tools into logical classes with `[McpServerToolType]` +- Consider security implications when exposing tools that access external resources +- Use the built-in DI container to manage service lifetimes and dependencies +- Implement proper error handling and return meaningful error messages +- Test tools individually before integrating with LLMs + +## Common Patterns + +### Basic Server Setup +```csharp +var builder = Host.CreateApplicationBuilder(args); +builder.Logging.AddConsole(options => + options.LogToStandardErrorThreshold = LogLevel.Trace); +builder.Services + .AddMcpServer() + .WithStdioServerTransport() + .WithToolsFromAssembly(); +await builder.Build().RunAsync(); +``` + +### Simple Tool +```csharp +[McpServerToolType] +public static class MyTools +{ + [McpServerTool, Description("Description of what the tool does")] + public static string ToolName( + [Description("Parameter description")] string param) => + $"Result: {param}"; +} +``` + +### Tool with Dependency Injection +```csharp +[McpServerTool, Description("Fetches data from a URL")] +public static async Task FetchData( + HttpClient httpClient, + [Description("The URL to fetch")] string url, + CancellationToken cancellationToken) => + await httpClient.GetStringAsync(url, cancellationToken); +``` + +### Tool with Sampling +```csharp +[McpServerTool, Description("Analyzes content using the client's LLM")] +public static async Task Analyze( + McpServer server, + [Description("Content to analyze")] string content, + CancellationToken cancellationToken) +{ + var messages = new ChatMessage[] + { + new(ChatRole.User, $"Analyze this: {content}") + }; + return await server.AsSamplingChatClient() + .GetResponseAsync(messages, cancellationToken: cancellationToken); +} +``` diff --git a/.github/instructions/repl.instructions.md b/.github/instructions/repl.instructions.md new file mode 100644 index 0000000000000000000000000000000000000000..8b73c063b693f640c8e49b55cf9c11e35fe39951 --- /dev/null +++ b/.github/instructions/repl.instructions.md @@ -0,0 +1,197 @@ +--- +scope: + languages: + - csharp + patterns: + - "**/*repl*" + - "**/*REPL*" + - "**/*eval*" + - "**/*interactive*" +--- + +# C# REPL Instructions + +## Dogfooding: Test Your REPL Changes + +When working on REPL functionality, **ALWAYS** use the MCP tools to test your changes: +- Use `EvaluateCsharp` to test the code patterns you're implementing +- Use `ValidateCsharp` to verify syntax of example code +- Access `repl://state` or `repl://sessions` resources to understand current REPL capabilities +- This ensures the REPL works correctly and validates the very functionality you're building + +## REPL Implementation + +When working on REPL (Read-Eval-Print Loop) functionality: + +### Core Requirements +1. **Read**: Parse user input safely and correctly +2. **Eval**: Compile and execute C# code using Roslyn +3. **Print**: Return results in a structured, LLM-friendly format +4. **Loop**: Maintain state between evaluations + +### Code Patterns + +#### Script Execution +```csharp +using Microsoft.CodeAnalysis.CSharp.Scripting; +using Microsoft.CodeAnalysis.Scripting; + +public async Task EvaluateAsync(string code, ScriptState scriptState = null) +{ + try + { + var options = ScriptOptions.Default + .AddReferences(GetAssemblyReferences()) + .AddImports(GetDefaultImports()); + + if (scriptState == null) + { + scriptState = await CSharpScript.RunAsync(code, options); + } + else + { + scriptState = await scriptState.ContinueWithAsync(code, options); + } + + return scriptState.ReturnValue; + } + catch (CompilationErrorException ex) + { + return CreateCompilationError(ex); + } +} +``` + +#### Error Handling +Provide actionable error messages: +```csharp +private ErrorResponse CreateCompilationError(CompilationErrorException ex) +{ + return new ErrorResponse + { + Type = "CompilationError", + Message = "Failed to compile the code", + Diagnostics = ex.Diagnostics.Select(d => new Diagnostic + { + Severity = d.Severity.ToString(), + Message = d.GetMessage(), + Location = d.Location.GetLineSpan().ToString(), + HelpLink = d.Descriptor.HelpLinkUri, + Suggestion = GetSuggestion(d) + }).ToList() + }; +} +``` + +### State Management + +Maintain execution context across evaluations: +- Store variable definitions +- Preserve namespace imports +- Track assembly references +- Manage execution history + +### NuGet Integration + +Support dynamic package loading: +```csharp +public async Task AddPackageAsync(string packageId, string version = null) +{ + // Resolve package dependencies + var packages = await ResolvePackageAsync(packageId, version); + + // Add assemblies to script options + foreach (var package in packages) + { + AddAssemblyReference(package.AssemblyPath); + } + + return true; +} +``` + +### Intellisense Support + +Provide code completion and documentation: +- Use Roslyn's completion service +- Return symbol information +- Include XML documentation +- Support signature help + +### LLM-Friendly Output + +Structure responses for LLM consumption: +```csharp +public class EvaluationResult +{ + public bool Success { get; set; } + public object Value { get; set; } + public string Type { get; set; } + public string FormattedValue { get; set; } + public List Warnings { get; set; } + public ExecutionMetrics Metrics { get; set; } +} +``` + +## Security Considerations + +### Code Sandboxing +- Restrict access to file system operations +- Limit network access +- Prevent infinite loops (timeout) +- Restrict memory usage +- Disable unsafe code by default + +### Input Validation +- Validate code syntax before execution +- Check for prohibited patterns +- Sanitize user inputs +- Prevent code injection + +## Performance Optimization + +### Compilation Caching +- Cache compiled scripts when possible +- Reuse script state between evaluations +- Pre-load common assemblies +- Use incremental compilation + +### Resource Management +- Implement execution timeouts +- Limit memory allocation +- Clean up resources properly +- Monitor execution metrics + +## Testing + +### Unit Tests +- Test valid C# code execution +- Test error handling for invalid code +- Test state persistence +- Test package loading +- Test security restrictions + +### Integration Tests +- Test with complex C# scripts +- Test package dependencies +- Test long-running evaluations +- Test memory limits + +## Documentation + +Document REPL features: +- Supported C# language features +- Available commands (e.g., #load, #r) +- State management behavior +- Limitations and restrictions +- Usage examples + +## Best Practices + +1. **Isolation**: Isolate REPL sessions from each other +2. **Diagnostics**: Provide detailed diagnostic information +3. **Help**: Include built-in help system +4. **History**: Maintain command history +5. **Extensibility**: Support custom commands and extensions +6. **Formatting**: Pretty-print complex objects +7. **Async Support**: Handle async/await in user code diff --git a/.github/instructions/testing.instructions.md b/.github/instructions/testing.instructions.md new file mode 100644 index 0000000000000000000000000000000000000000..3b1660c2b60d9138721b56e50990284da441ea7e --- /dev/null +++ b/.github/instructions/testing.instructions.md @@ -0,0 +1,550 @@ +--- +scope: + patterns: + - "**/test/**" + - "**/tests/**" + - "**/*Test.cs" + - "**/*Tests.cs" + - "**/*.test.cs" + - "**/*.tests.cs" +--- + +# Testing Instructions + +## Using MCP Tools for Test Development + +When writing tests, use the roslyn-stone MCP tools to validate test code: +- Use `ValidateCsharp` to check test code syntax +- Use `EvaluateCsharp` to verify test assertions and expected behavior +- Access `doc://{symbolName}` resources to look up xUnit attributes and .NET testing APIs +- This ensures test code is correct before running the full test suite + +## Testing Framework + +Use xUnit as the primary testing framework for consistency with .NET conventions. + +### Test Structure +```csharp +public class ComponentTests +{ + [Fact] + public void MethodName_Scenario_ExpectedBehavior() + { + // Arrange + var component = new Component(); + var input = "test data"; + + // Act + var result = component.Method(input); + + // Assert + Assert.Equal(expected, result); + } + + [Theory] + [InlineData("input1", "expected1")] + [InlineData("input2", "expected2")] + public void MethodName_WithVariousInputs_ReturnsExpectedResults( + string input, string expected) + { + // Arrange & Act + var result = Component.Method(input); + + // Assert + Assert.Equal(expected, result); + } +} +``` + +## Test Categories + +### Unit Tests +- Test individual components in isolation +- Mock external dependencies +- Fast execution (< 100ms per test) +- Deterministic and repeatable + +### Integration Tests +```csharp +[Collection("Integration")] +public class McpServerIntegrationTests +{ + [Fact] + public async Task McpServer_ExecutesTool_ReturnsExpectedResult() + { + // Arrange + using var server = CreateTestServer(); + await server.StartAsync(); + + // Act + var result = await server.ExecuteToolAsync("tool_name", parameters); + + // Assert + Assert.NotNull(result); + Assert.True(result.Success); + + // Cleanup + await server.StopAsync(); + } +} +``` + +### End-to-End Tests +- Test complete workflows +- Use minimal mocking +- Test realistic scenarios +- May be slower but provide high confidence + +## Mocking + +Use Moq for creating test doubles: +```csharp +[Fact] +public async Task Service_WithMockedDependency_BehavesCorrectly() +{ + // Arrange + var mockRepo = new Mock(); + mockRepo.Setup(r => r.GetAsync(It.IsAny())) + .ReturnsAsync(new Entity()); + + var service = new Service(mockRepo.Object); + + // Act + var result = await service.ProcessAsync("test"); + + // Assert + mockRepo.Verify(r => r.GetAsync("test"), Times.Once); + Assert.NotNull(result); +} +``` + +## Test Data + +### Test Fixtures +```csharp +public class TestFixture : IDisposable +{ + public TestServer Server { get; } + + public TestFixture() + { + Server = CreateTestServer(); + } + + public void Dispose() + { + Server?.Dispose(); + } +} + +[CollectionDefinition("Integration")] +public class IntegrationCollection : ICollectionFixture +{ +} +``` + +### Test Data Builders +```csharp +public class EntityBuilder +{ + private string _name = "default"; + private int _value = 0; + + public EntityBuilder WithName(string name) + { + _name = name; + return this; + } + + public EntityBuilder WithValue(int value) + { + _value = value; + return this; + } + + public Entity Build() => new Entity { Name = _name, Value = _value }; +} +``` + +## REPL Testing + +Test REPL functionality thoroughly: +```csharp +[Fact] +public async Task Repl_EvaluatesSimpleExpression_ReturnsResult() +{ + // Arrange + var repl = new CSharpRepl(); + + // Act + var result = await repl.EvaluateAsync("1 + 1"); + + // Assert + Assert.True(result.Success); + Assert.Equal(2, result.Value); + Assert.Equal("System.Int32", result.Type); +} + +[Fact] +public async Task Repl_WithSyntaxError_ReturnsActionableError() +{ + // Arrange + var repl = new CSharpRepl(); + + // Act + var result = await repl.EvaluateAsync("var x = "); + + // Assert + Assert.False(result.Success); + Assert.NotNull(result.Error); + Assert.Contains("syntax error", result.Error.Message, StringComparison.OrdinalIgnoreCase); + Assert.NotEmpty(result.Error.Diagnostics); +} +``` + +## MCP Testing + +Test MCP server operations: +```csharp +[Fact] +public async Task McpServer_DiscoverTools_ReturnsAllTools() +{ + // Arrange + var server = CreateMcpServer(); + + // Act + var tools = await server.DiscoverToolsAsync(); + + // Assert + Assert.NotEmpty(tools); + Assert.All(tools, tool => + { + Assert.NotNull(tool.Name); + Assert.NotNull(tool.Description); + Assert.NotNull(tool.Schema); + }); +} +``` + +## Error Testing + +Always test error conditions: +```csharp +[Fact] +public async Task Method_WithInvalidInput_ThrowsArgumentException() +{ + // Arrange + var component = new Component(); + + // Act & Assert + await Assert.ThrowsAsync( + async () => await component.MethodAsync(null) + ); +} + +[Fact] +public async Task Method_WithInvalidInput_ReturnsErrorResult() +{ + // Arrange + var component = new Component(); + + // Act + var result = await component.TryMethodAsync(null); + + // Assert + Assert.False(result.Success); + Assert.NotNull(result.Error); + Assert.Contains("invalid input", result.Error.Message); +} +``` + +## Async Testing + +Properly test async operations: +```csharp +[Fact] +public async Task AsyncMethod_CompletesSuccessfully() +{ + // Arrange + var service = new Service(); + + // Act + var result = await service.ExecuteAsync(); + + // Assert + Assert.NotNull(result); +} + +[Fact] +public async Task AsyncMethod_WithCancellation_ThrowsOperationCanceledException() +{ + // Arrange + var service = new Service(); + var cts = new CancellationTokenSource(); + cts.Cancel(); + + // Act & Assert + await Assert.ThrowsAsync( + async () => await service.ExecuteAsync(cts.Token) + ); +} +``` + +## Test Naming + +Use descriptive test names: +- `Method_Scenario_ExpectedBehavior` +- `Given_Precondition_When_Action_Then_Outcome` +- Be specific and clear about what is being tested + +## Assertions + +Use appropriate assertions: +- `Assert.Equal()` for value equality +- `Assert.Same()` for reference equality +- `Assert.True()/False()` for boolean conditions +- `Assert.NotNull()` for existence checks +- `Assert.Throws<>()` for exception testing +- `Assert.Collection()` for collection testing + +## Test Coverage + +Aim for: +- **Line Coverage**: > 80% (currently 86.67%) +- **Branch Coverage**: > 75% (currently 62.98%) +- **Critical Paths**: 100% + +Focus on testing: +- Public API surface +- Error handling paths +- Edge cases and boundaries +- Security-sensitive code +- Complex business logic + +### Running Coverage Reports + +```bash +# Run tests with coverage +dotnet cake --target=Test-Coverage + +# Generate HTML coverage report +dotnet cake --target=Test-Coverage-Report +# Opens at ./artifacts/coverage-report/index.html +``` + +The coverage task: +- Runs all tests with code coverage collection +- Validates line and branch coverage thresholds +- Generates Cobertura XML reports +- Displays coverage percentages in CI output +- Warns if coverage falls below thresholds (80% line, 75% branch) + +### Coverage Best Practices + +- Write tests that exercise different code paths (branches) +- Test both success and error scenarios +- Test edge cases and boundary conditions +- Use `DefaultIfEmpty()` before `Average()` to handle empty sequences +- Proper resource disposal with `using` statements improves coverage accuracy + +## Performance Testing + +For performance-critical code: +```csharp +[Fact] +public async Task Method_Completes_WithinTimeLimit() +{ + // Arrange + var component = new Component(); + var stopwatch = Stopwatch.StartNew(); + + // Act + await component.ExpensiveOperationAsync(); + stopwatch.Stop(); + + // Assert + Assert.True(stopwatch.ElapsedMilliseconds < 1000, + $"Operation took {stopwatch.ElapsedMilliseconds}ms"); +} +``` + +## Best Practices + +1. **Independence**: Tests should not depend on each other +2. **Repeatability**: Tests should produce the same result every time +3. **Clarity**: Test code should be readable and maintainable +4. **Speed**: Keep tests fast to encourage frequent execution +5. **Isolation**: Use mocks to isolate the system under test +6. **AAA Pattern**: Arrange, Act, Assert structure +7. **One Assertion**: Focus each test on one logical assertion +8. **Test Names**: Use descriptive names that explain the test +9. **Resource Disposal**: Always use `using` for IDisposable (CancellationTokenSource, HttpClient, etc.) +10. **Avoid Code Smells**: No `Assert.True(true)` or tautology assertions + +## Benchmarking (BenchmarkDotNet) + +The `RoslynStone.Benchmarks` project tracks performance of critical operations. + +### Available Benchmarks + +- **RoslynScriptingServiceBenchmarks**: REPL execution performance (5 scenarios) + - Simple expressions, variable assignments, LINQ queries, complex operations, string manipulation +- **CompilationServiceBenchmarks**: Code compilation performance (4 scenarios) + - Simple class compilation, complex code, error handling, multiple classes +- **NuGetServiceBenchmarks**: Package operations performance (3 scenarios) + - Package search, version lookup, README retrieval + +### Running Benchmarks + +```bash +# Run all benchmarks in Release mode +dotnet cake --target=Benchmark + +# Run specific benchmark class +dotnet run --project tests/RoslynStone.Benchmarks --configuration Release -- --filter *RoslynScriptingService* + +# Run with custom BenchmarkDotNet options +dotnet run --project tests/RoslynStone.Benchmarks --configuration Release -- --job short +``` + +### Benchmark Best Practices + +- Always run in **Release** configuration +- Close other applications to minimize interference +- Run multiple iterations for statistical significance +- Use `[MemoryDiagnoser]` to track allocations +- Add `[GlobalSetup]` and `[GlobalCleanup]` for resource management +- Results saved to `./artifacts/benchmarks/` + +### Adding New Benchmarks + +```csharp +[MemoryDiagnoser] +[MinColumn, MaxColumn, MeanColumn, MedianColumn] +public class MyServiceBenchmarks +{ + private MyService _service = null!; + + [GlobalSetup] + public void Setup() + { + _service = new MyService(); + } + + [Benchmark] + public async Task BenchmarkOperation() + { + return await _service.OperationAsync(); + } + + [GlobalCleanup] + public void Cleanup() + { + _service?.Dispose(); + } +} +``` + +## Load Testing + +The `RoslynStone.LoadTests` project validates HTTP MCP server scalability. + +### Load Test Configuration + +- **Default concurrency**: 300 concurrent requests per round +- **Default rounds**: 10 rounds per scenario +- **Test scenarios**: 4 (expressions, LINQ, variable assignments, NuGet search) +- **Total requests**: 12,000 (300 × 10 × 4) +- **Metrics**: Throughput, latency, success rate, response times + +### Running Load Tests + +```bash +# 1. Start the server in HTTP mode +cd src/RoslynStone.Api +MCP_TRANSPORT=http dotnet run + +# 2. In another terminal, run load tests +cd /path/to/repo +dotnet cake --target=Load-Test + +# Or with custom configuration +dotnet run --project tests/RoslynStone.LoadTests -- http://localhost:7071 300 10 +# Arguments: [baseUrl] [concurrency] [rounds] +``` + +### Expected Performance + +A healthy server should achieve: +- ✅ Success rate > 99% +- ✅ Average response time < 100ms for simple operations +- ✅ Throughput > 1000 requests/second + +### Load Test Metrics + +The tool reports for each scenario: +- **Average Round Time**: Time to complete all concurrent requests +- **Average Response Time**: Per-request response time +- **Success Rate**: Percentage of successful requests +- **Throughput**: Requests per second +- **Total Success/Failures**: Request counts + +### Adding Load Test Scenarios + +```csharp +private static string CreateNewScenarioRequest() +{ + var request = new + { + jsonrpc = "2.0", + method = "tools/call", + @params = new + { + name = "ToolName", + arguments = new { param = "value" } + }, + id = 1 + }; + return JsonSerializer.Serialize(request); +} +``` + +## CI Integration + +All test infrastructure is integrated with CI: + +```bash +# Full CI pipeline (includes coverage validation) +dotnet cake --target=CI + +# Individual tasks +dotnet cake --target=Format-Check # CSharpier formatting +dotnet cake --target=Inspect # ReSharper analysis +dotnet cake --target=Build # Build solution +dotnet cake --target=Test-Coverage # Tests with coverage +``` + +### CI Artifacts + +- Test results (`.trx` files) +- Coverage reports (Cobertura XML) +- ReSharper inspection reports +- Build logs + +## Test Organization + +``` +tests/ +├── RoslynStone.Tests/ # Unit & integration tests (xUnit) +│ ├── *ServiceTests.cs # Service-level unit tests +│ ├── *IntegrationTests.cs # Integration test suites +│ ├── DiagnosticHelpersTests.cs +│ └── CompilationServiceEdgeCasesTests.cs +├── RoslynStone.Benchmarks/ # Performance benchmarks +│ ├── *ServiceBenchmarks.cs +│ ├── Program.cs +│ └── README.md +└── RoslynStone.LoadTests/ # Load & concurrency tests + ├── Program.cs + └── README.md +``` diff --git a/.github/prompts/aspnet-minimal-api-openapi.prompt.md b/.github/prompts/aspnet-minimal-api-openapi.prompt.md new file mode 100644 index 0000000000000000000000000000000000000000..6ee94c014e5d4e0e0cd33054eb78cd742647d9be --- /dev/null +++ b/.github/prompts/aspnet-minimal-api-openapi.prompt.md @@ -0,0 +1,42 @@ +--- +agent: 'agent' +tools: ['changes', 'search/codebase', 'edit/editFiles', 'problems'] +description: 'Create ASP.NET Minimal API endpoints with proper OpenAPI documentation' +--- + +# ASP.NET Minimal API with OpenAPI + +Your goal is to help me create well-structured ASP.NET Minimal API endpoints with correct types and comprehensive OpenAPI/Swagger documentation. + +## API Organization + +- Group related endpoints using `MapGroup()` extension +- Use endpoint filters for cross-cutting concerns +- Structure larger APIs with separate endpoint classes +- Consider using a feature-based folder structure for complex APIs + +## Request and Response Types + +- Define explicit request and response DTOs/models +- Create clear model classes with proper validation attributes +- Use record types for immutable request/response objects +- Use meaningful property names that align with API design standards +- Apply `[Required]` and other validation attributes to enforce constraints +- Use the ProblemDetailsService and StatusCodePages to get standard error responses + +## Type Handling + +- Use strongly-typed route parameters with explicit type binding +- Use `Results` to represent multiple response types +- Return `TypedResults` instead of `Results` for strongly-typed responses +- Leverage C# 10+ features like nullable annotations and init-only properties + +## OpenAPI Documentation + +- Use the built-in OpenAPI document support added in .NET 9 +- Define operation summary and description +- Add operationIds using the `WithName` extension method +- Add descriptions to properties and parameters with `[Description()]` +- Set proper content types for requests and responses +- Use document transformers to add elements like servers, tags, and security schemes +- Use schema transformers to apply customizations to OpenAPI schemas diff --git a/.github/prompts/csharp-async.prompt.md b/.github/prompts/csharp-async.prompt.md new file mode 100644 index 0000000000000000000000000000000000000000..8291c350473b7848fea9567cf5e1effd3c466dd3 --- /dev/null +++ b/.github/prompts/csharp-async.prompt.md @@ -0,0 +1,50 @@ +--- +agent: 'agent' +tools: ['changes', 'search/codebase', 'edit/editFiles', 'problems'] +description: 'Get best practices for C# async programming' +--- + +# C# Async Programming Best Practices + +Your goal is to help me follow best practices for asynchronous programming in C#. + +## Naming Conventions + +- Use the 'Async' suffix for all async methods +- Match method names with their synchronous counterparts when applicable (e.g., `GetDataAsync()` for `GetData()`) + +## Return Types + +- Return `Task` when the method returns a value +- Return `Task` when the method doesn't return a value +- Consider `ValueTask` for high-performance scenarios to reduce allocations +- Avoid returning `void` for async methods except for event handlers + +## Exception Handling + +- Use try/catch blocks around await expressions +- Avoid swallowing exceptions in async methods +- Use `ConfigureAwait(false)` when appropriate to prevent deadlocks in library code +- Propagate exceptions with `Task.FromException()` instead of throwing in async Task returning methods + +## Performance + +- Use `Task.WhenAll()` for parallel execution of multiple tasks +- Use `Task.WhenAny()` for implementing timeouts or taking the first completed task +- Avoid unnecessary async/await when simply passing through task results +- Consider cancellation tokens for long-running operations + +## Common Pitfalls + +- Never use `.Wait()`, `.Result`, or `.GetAwaiter().GetResult()` in async code +- Avoid mixing blocking and async code +- Don't create async void methods (except for event handlers) +- Always await Task-returning methods + +## Implementation Patterns + +- Implement the async command pattern for long-running operations +- Use async streams (IAsyncEnumerable) for processing sequences asynchronously +- Consider the task-based asynchronous pattern (TAP) for public APIs + +When reviewing my C# code, identify these issues and suggest improvements that follow these best practices. diff --git a/.github/prompts/csharp-mcp-server-generator.prompt.md b/.github/prompts/csharp-mcp-server-generator.prompt.md new file mode 100644 index 0000000000000000000000000000000000000000..e0218d01ff2ec7cf0ece3af13f5725d7dd771871 --- /dev/null +++ b/.github/prompts/csharp-mcp-server-generator.prompt.md @@ -0,0 +1,59 @@ +--- +agent: 'agent' +description: 'Generate a complete MCP server project in C# with tools, prompts, and proper configuration' +--- + +# Generate C# MCP Server + +Create a complete Model Context Protocol (MCP) server in C# with the following specifications: + +## Requirements + +1. **Project Structure**: Create a new C# console application with proper directory structure +2. **NuGet Packages**: Include ModelContextProtocol (prerelease) and Microsoft.Extensions.Hosting +3. **Logging Configuration**: Configure all logs to stderr to avoid interfering with stdio transport +4. **Server Setup**: Use the Host builder pattern with proper DI configuration +5. **Tools**: Create at least one useful tool with proper attributes and descriptions +6. **Error Handling**: Include proper error handling and validation + +## Implementation Details + +### Basic Project Setup +- Use .NET 8.0 or later +- Create a console application +- Add necessary NuGet packages with --prerelease flag +- Configure logging to stderr + +### Server Configuration +- Use `Host.CreateApplicationBuilder` for DI and lifecycle management +- Configure `AddMcpServer()` with stdio transport +- Use `WithToolsFromAssembly()` for automatic tool discovery +- Ensure the server runs with `RunAsync()` + +### Tool Implementation +- Use `[McpServerToolType]` attribute on tool classes +- Use `[McpServerTool]` attribute on tool methods +- Add `[Description]` attributes to tools and parameters +- Support async operations where appropriate +- Include proper parameter validation + +### Code Quality +- Follow C# naming conventions +- Include XML documentation comments +- Use nullable reference types +- Implement proper error handling with McpProtocolException +- Use structured logging for debugging + +## Example Tool Types to Consider +- File operations (read, write, search) +- Data processing (transform, validate, analyze) +- External API integrations (HTTP requests) +- System operations (execute commands, check status) +- Database operations (query, update) + +## Testing Guidance +- Explain how to run the server +- Provide example commands to test with MCP clients +- Include troubleshooting tips + +Generate a complete, production-ready MCP server with comprehensive documentation and error handling. diff --git a/.github/prompts/csharp-xunit.prompt.md b/.github/prompts/csharp-xunit.prompt.md new file mode 100644 index 0000000000000000000000000000000000000000..2859d2276a3b81543bbbc8af3085551b03157a2f --- /dev/null +++ b/.github/prompts/csharp-xunit.prompt.md @@ -0,0 +1,69 @@ +--- +agent: 'agent' +tools: ['changes', 'search/codebase', 'edit/editFiles', 'problems', 'search'] +description: 'Get best practices for XUnit unit testing, including data-driven tests' +--- + +# XUnit Best Practices + +Your goal is to help me write effective unit tests with XUnit, covering both standard and data-driven testing approaches. + +## Project Setup + +- Use a separate test project with naming convention `[ProjectName].Tests` +- Reference Microsoft.NET.Test.Sdk, xunit, and xunit.runner.visualstudio packages +- Create test classes that match the classes being tested (e.g., `CalculatorTests` for `Calculator`) +- Use .NET SDK test commands: `dotnet test` for running tests + +## Test Structure + +- No test class attributes required (unlike MSTest/NUnit) +- Use fact-based tests with `[Fact]` attribute for simple tests +- Follow the Arrange-Act-Assert (AAA) pattern +- Name tests using the pattern `MethodName_Scenario_ExpectedBehavior` +- Use constructor for setup and `IDisposable.Dispose()` for teardown +- Use `IClassFixture` for shared context between tests in a class +- Use `ICollectionFixture` for shared context between multiple test classes + +## Standard Tests + +- Keep tests focused on a single behavior +- Avoid testing multiple behaviors in one test method +- Use clear assertions that express intent +- Include only the assertions needed to verify the test case +- Make tests independent and idempotent (can run in any order) +- Avoid test interdependencies + +## Data-Driven Tests + +- Use `[Theory]` combined with data source attributes +- Use `[InlineData]` for inline test data +- Use `[MemberData]` for method-based test data +- Use `[ClassData]` for class-based test data +- Create custom data attributes by implementing `DataAttribute` +- Use meaningful parameter names in data-driven tests + +## Assertions + +- Use `Assert.Equal` for value equality +- Use `Assert.Same` for reference equality +- Use `Assert.True`/`Assert.False` for boolean conditions +- Use `Assert.Contains`/`Assert.DoesNotContain` for collections +- Use `Assert.Matches`/`Assert.DoesNotMatch` for regex pattern matching +- Use `Assert.Throws` or `await Assert.ThrowsAsync` to test exceptions +- Use fluent assertions library for more readable assertions + +## Mocking and Isolation + +- Consider using Moq or NSubstitute alongside XUnit +- Mock dependencies to isolate units under test +- Use interfaces to facilitate mocking +- Consider using a DI container for complex test setups + +## Test Organization + +- Group tests by feature or component +- Use `[Trait("Category", "CategoryName")]` for categorization +- Use collection fixtures to group tests with shared dependencies +- Consider output helpers (`ITestOutputHelper`) for test diagnostics +- Skip tests conditionally with `Skip = "reason"` in fact/theory attributes diff --git a/.github/prompts/dotnet-best-practices.prompt.md b/.github/prompts/dotnet-best-practices.prompt.md new file mode 100644 index 0000000000000000000000000000000000000000..cad0f15e9896364e3d7f97672d3786e989e9aaf7 --- /dev/null +++ b/.github/prompts/dotnet-best-practices.prompt.md @@ -0,0 +1,84 @@ +--- +agent: 'agent' +description: 'Ensure .NET/C# code meets best practices for the solution/project.' +--- +# .NET/C# Best Practices + +Your task is to ensure .NET/C# code in ${selection} meets the best practices specific to this solution/project. This includes: + +## Documentation & Structure + +- Create comprehensive XML documentation comments for all public classes, interfaces, methods, and properties +- Include parameter descriptions and return value descriptions in XML comments +- Follow the established namespace structure: {Core|Console|App|Service}.{Feature} + +## Design Patterns & Architecture + +- Use primary constructor syntax for dependency injection (e.g., `public class MyClass(IDependency dependency)`) +- Implement the Command Handler pattern with generic base classes (e.g., `CommandHandler`) +- Use interface segregation with clear naming conventions (prefix interfaces with 'I') +- Follow the Factory pattern for complex object creation. + +## Dependency Injection & Services + +- Use constructor dependency injection with null checks via ArgumentNullException +- Register services with appropriate lifetimes (Singleton, Scoped, Transient) +- Use Microsoft.Extensions.DependencyInjection patterns +- Implement service interfaces for testability + +## Resource Management & Localization + +- Use ResourceManager for localized messages and error strings +- Separate LogMessages and ErrorMessages resource files +- Access resources via `_resourceManager.GetString("MessageKey")` + +## Async/Await Patterns + +- Use async/await for all I/O operations and long-running tasks +- Return Task or Task from async methods +- Use ConfigureAwait(false) where appropriate +- Handle async exceptions properly + +## Testing Standards + +- Use MSTest framework with FluentAssertions for assertions +- Follow AAA pattern (Arrange, Act, Assert) +- Use Moq for mocking dependencies +- Test both success and failure scenarios +- Include null parameter validation tests + +## Configuration & Settings + +- Use strongly-typed configuration classes with data annotations +- Implement validation attributes (Required, NotEmptyOrWhitespace) +- Use IConfiguration binding for settings +- Support appsettings.json configuration files + +## Semantic Kernel & AI Integration + +- Use Microsoft.SemanticKernel for AI operations +- Implement proper kernel configuration and service registration +- Handle AI model settings (ChatCompletion, Embedding, etc.) +- Use structured output patterns for reliable AI responses + +## Error Handling & Logging + +- Use structured logging with Microsoft.Extensions.Logging +- Include scoped logging with meaningful context +- Throw specific exceptions with descriptive messages +- Use try-catch blocks for expected failure scenarios + +## Performance & Security + +- Use C# 12+ features and .NET 8 optimizations where applicable +- Implement proper input validation and sanitization +- Use parameterized queries for database operations +- Follow secure coding practices for AI/ML operations + +## Code Quality + +- Ensure SOLID principles compliance +- Avoid code duplication through base classes and utilities +- Use meaningful names that reflect domain concepts +- Keep methods focused and cohesive +- Implement proper disposal patterns for resources diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000000000000000000000000000000000000..141dcdf4954ebb8f8ce682145cc2a18c0a44934c --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,101 @@ +name: CI + +on: + push: + branches: [ main, develop ] + pull_request: + branches: [ main, develop ] + workflow_dispatch: + +jobs: + ci: + name: Build and Test + runs-on: ubuntu-latest + timeout-minutes: 30 + + steps: + - name: Checkout code + uses: actions/checkout@v4 + + - name: Setup .NET Tools + uses: ./.github/actions/setup-dotnet-tools + with: + dotnet-version: '10.0.x' + + - name: Setup Python for Gradio tests + uses: actions/setup-python@v5 + with: + python-version: '3.12' + + - name: Install Playwright browsers + timeout-minutes: 5 + run: | + # Install Playwright CLI + dotnet tool install -g Microsoft.Playwright.CLI || true + + # Install Chromium with system dependencies + playwright install --with-deps chromium + + - name: Install UV and Python dependencies + timeout-minutes: 5 + run: | + # Install UV + curl -LsSf https://astral.sh/uv/install.sh | sh + export PATH="$HOME/.local/bin:$PATH" + + # Create a virtual environment in the expected location for both Debug and Release + # The test build uses Debug, but Cake CI uses Release + for CONFIG in Debug Release; do + VENV_PATH="${{ github.workspace }}/src/RoslynStone.Api/bin/$CONFIG/net10.0/.venv" + mkdir -p "$(dirname "$VENV_PATH")" + python -m venv "$VENV_PATH" + + # Install dependencies with pre-releases allowed (gradio 6.0 needs gradio-client 2.0.0.dev3) + uv pip install --python "$VENV_PATH/bin/python" --prerelease=allow \ + gradio>=6.0.0 \ + httpx>=0.25.0 \ + openai>=1.0.0 \ + anthropic>=0.18.0 \ + google-generativeai>=0.3.0 \ + huggingface_hub>=0.20.0 \ + pygments>=2.17.0 + done + + # Install Python quality tools in project venv for quality checks + cd src/RoslynStone.GradioModule + uv pip install --prerelease=allow ruff mypy types-pygments + + - name: Run Cake CI + timeout-minutes: 20 + run: dotnet cake --target=CI --configuration=Release + env: + # Skip CSnakes Python install since we pre-installed deps + SKIP_PYTHON_INSTALL: 'true' + # Allow pre-release packages for UV (fallback if needed) + UV_PRERELEASE: 'allow' + + - name: Upload test results + uses: actions/upload-artifact@v4 + if: always() + with: + name: test-results + path: | + **/TestResults/**/*.trx + **/TestResults/**/*.xml + retention-days: 30 + + - name: Upload coverage artifacts + uses: actions/upload-artifact@v4 + if: always() + with: + name: coverage-report + path: artifacts/coverage/** + retention-days: 30 + + - name: Upload ReSharper inspection report + uses: actions/upload-artifact@v4 + if: always() + with: + name: resharper-report + path: artifacts/resharper-report.xml + retention-days: 30 diff --git a/.github/workflows/container.yml b/.github/workflows/container.yml new file mode 100644 index 0000000000000000000000000000000000000000..dadaf735c629bd43bbf563882088d5f59624ccb9 --- /dev/null +++ b/.github/workflows/container.yml @@ -0,0 +1,134 @@ +name: Build and Publish Container + +on: + workflow_dispatch: + +env: + REGISTRY: ghcr.io + IMAGE_NAME: ${{ github.repository }} + # For automatic pushes to Hugging Face Spaces, add + # 'HF_TOKEN' as a repository secret pointing to a Hugging Face access token + # with 'repo' scope for the target space `MCP-1st-Birthday/Roslyn-Stone`. + +jobs: + build-and-push: + name: Build and Push Container Image + environment: + name: production + runs-on: ubuntu-latest + timeout-minutes: 45 + permissions: + contents: read + packages: write + id-token: write + attestations: write + + steps: + - name: Checkout code + uses: actions/checkout@v4 + with: + fetch-depth: 0 + + - name: Log in to GitHub Container Registry + if: github.event_name != 'pull_request' + uses: docker/login-action@v3 + with: + registry: ${{ env.REGISTRY }} + username: ${{ github.actor }} + password: ${{ secrets.GITHUB_TOKEN }} + + - name: Extract Docker metadata + id: meta + uses: docker/metadata-action@v5 + with: + images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }} + tags: | + type=ref,event=branch + type=ref,event=pr + type=semver,pattern={{version}} + type=semver,pattern={{major}}.{{minor}} + type=semver,pattern={{major}} + type=sha,prefix={{branch}}- + type=raw,value=latest,enable={{is_default_branch}} + + - name: Set up Docker Buildx + uses: docker/setup-buildx-action@v3 + + - name: Build and push Docker image + uses: docker/build-push-action@v6 + id: build + timeout-minutes: 30 + with: + context: . + file: ./src/RoslynStone.Api/Dockerfile + push: ${{ github.event_name != 'pull_request' }} + tags: ${{ steps.meta.outputs.tags }} + labels: ${{ steps.meta.outputs.labels }} + cache-from: type=gha + cache-to: type=gha,mode=max + platforms: linux/amd64,linux/arm64 + + - name: Generate artifact attestation + if: github.event_name != 'pull_request' + uses: actions/attest-build-provenance@v2 + with: + subject-name: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }} + subject-digest: ${{ steps.build.outputs.digest }} + push-to-registry: true + + # Upload repository or built artifacts to Hugging Face Space + - name: Set up Python for `hf` CLI + if: github.event_name != 'pull_request' && github.ref == 'refs/heads/main' + uses: actions/setup-python@v4 + with: + python-version: '3.11' + + - name: Install HF CLI + if: github.event_name != 'pull_request' && github.ref == 'refs/heads/main' + timeout-minutes: 2 + run: | + python -m pip install --upgrade pip + pip install huggingface-hub + # Try to install the `uvx` wrapper if available; do not fail if not published + pip install uvx || true + command -v uvx || true + hf --version || true + env: + HF_TOKEN: ${{ secrets.HF_TOKEN }} + + - name: Login to Hugging Face (non-interactive using token) + if: github.event_name != 'pull_request' && github.ref == 'refs/heads/main' + timeout-minutes: 1 + run: | + set -eux + if [ -z "${HF_TOKEN}" ]; then + echo "HF_TOKEN missing; skipping 'hf auth login'"; + exit 0; + fi + # Try uvx hugging-cli if available + if command -v uvx >/dev/null 2>&1; then + uvx hugging-cli login --token "${HF_TOKEN}" || true + fi + hf auth login --token "${HF_TOKEN}" + env: + HF_TOKEN: ${{ secrets.HF_TOKEN }} + + - name: Upload to Hugging Face Space (using uvx if available, else hf) + if: github.event_name != 'pull_request' && github.ref == 'refs/heads/main' + timeout-minutes: 10 + run: | + # Use uvx wrapper if present, otherwise use hf CLI directly. + # This uploads the repository root while excluding common build and binary dirs. + set -eux + if [ -z "${HF_TOKEN}" ]; then + echo "HF_TOKEN is not set; skipping Hugging Face upload."; + exit 0; + fi + # Upload the repository root to the Space, excluding common build outputs + if command -v uvx >/dev/null 2>&1; then + uvx hf upload MCP-1st-Birthday/Roslyn-Stone . --repo-type=space --exclude="/.venv/*" --exclude="/bin/*" --exclude="/obj/*" --exclude="/tests/*" --exclude="/.github/*" --delete="*" --commit-message="CI: Sync from GitHub Actions ${GITHUB_SHA}" + else + hf upload MCP-1st-Birthday/Roslyn-Stone . --repo-type=space --exclude="/.venv/*" --exclude="/bin/*" --exclude="/obj/*" --exclude="/tests/*" --exclude="/.github/*" --delete="*" --commit-message="CI: Sync from GitHub Actions ${GITHUB_SHA}" + fi + env: + HF_TOKEN: ${{ secrets.HF_TOKEN }} diff --git a/.github/workflows/copilot-setup-steps.yml b/.github/workflows/copilot-setup-steps.yml new file mode 100644 index 0000000000000000000000000000000000000000..1d31cb6d6917b5c71ce8abc9de1e55dd513af869 --- /dev/null +++ b/.github/workflows/copilot-setup-steps.yml @@ -0,0 +1,83 @@ +name: "Copilot Setup Steps" + +# This workflow sets up the development environment for GitHub Copilot coding agent +# It preinstalls .NET 10, CSharpier, ReSharper CLI tools, and Cake build tool +on: + workflow_dispatch: + push: + paths: + - ".github/workflows/copilot-setup-steps.yml" + pull_request: + paths: + - ".github/workflows/copilot-setup-steps.yml" + +jobs: + copilot-setup-steps: + runs-on: ubuntu-latest + permissions: + contents: read + steps: + - name: Checkout repository + uses: actions/checkout@v4 + + - name: Setup .NET 10 + uses: actions/setup-dotnet@v4 + with: + dotnet-version: '10.0.x' + + - name: Display .NET version + run: dotnet --version + + - name: Install CSharpier (code formatter) + run: dotnet tool install --global csharpier + + - name: Install ReSharper Command Line Tools + run: dotnet tool install --global JetBrains.ReSharper.GlobalTools + + - name: Install Cake build tool + run: dotnet tool install --global Cake.Tool + + - name: Install dotnet-outdated (package update checker) + run: dotnet tool install --global dotnet-outdated-tool + + - name: Display installed global tools + run: dotnet tool list --global + + - name: Ensure NuGet cache directory exists + run: mkdir -p ~/.nuget/packages + shell: bash + + - name: Cache .NET packages + uses: actions/cache@v3 + with: + path: ~/.nuget/packages + key: ${{ runner.os }}-nuget-${{ hashFiles('**/*.csproj') }} + restore-keys: | + ${{ runner.os }}-nuget- + + - name: Restore .NET dependencies (if project files exist) + run: | + if compgen -G "*.sln" > /dev/null || compgen -G "**/*.csproj" > /dev/null; then + dotnet restore + else + echo "No .NET solution or project files found to restore" + fi + shell: bash + + - name: Verify tools installation + run: | + echo "=== Installed Tools ===" + echo "CSharpier version:" + dotnet csharpier --version || echo "CSharpier not found" + echo "" + echo "ReSharper CLI:" + jb || echo "ReSharper CLI not found" + echo "" + echo "Cake version:" + dotnet cake --version || echo "Cake not found" + echo "" + echo "dotnet-outdated version:" + dotnet-outdated --version || echo "dotnet-outdated not found" + echo "" + echo "=== Environment Ready ===" + shell: bash diff --git a/src/RoslynStone.AppHost/bin/Debug/net10.0/Aspire.Hosting.dll b/src/RoslynStone.AppHost/bin/Debug/net10.0/Aspire.Hosting.dll new file mode 100644 index 0000000000000000000000000000000000000000..b9dec0d2891d2bda6b7b7a7275c0d9e6af477e5a --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Debug/net10.0/Aspire.Hosting.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:882cc06ffa8687a9693ac397a7f7db07e1f60796abbfb41f889aed05f22b19c3 +size 1794080 diff --git a/src/RoslynStone.AppHost/bin/Debug/net10.0/Google.Protobuf.dll b/src/RoslynStone.AppHost/bin/Debug/net10.0/Google.Protobuf.dll new file mode 100644 index 0000000000000000000000000000000000000000..82d0e209dd1976c5acc0b3ac4effde0532d88353 --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Debug/net10.0/Google.Protobuf.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d792b92533fec450d21b9ac9e28b337fe25ac4982380eb932027b5fcc2036bf3 +size 497304 diff --git a/src/RoslynStone.AppHost/bin/Debug/net10.0/Grpc.AspNetCore.Server.dll b/src/RoslynStone.AppHost/bin/Debug/net10.0/Grpc.AspNetCore.Server.dll new file mode 100644 index 0000000000000000000000000000000000000000..13141ad6e185a08ef9f69c0cdab2fe45e40b1e39 --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Debug/net10.0/Grpc.AspNetCore.Server.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:aef8a51b4962e44429138557695acc148a5c5c80304337f247dd4b5ff22759d2 +size 159328 diff --git a/src/RoslynStone.AppHost/bin/Debug/net10.0/Grpc.Net.Client.dll b/src/RoslynStone.AppHost/bin/Debug/net10.0/Grpc.Net.Client.dll new file mode 100644 index 0000000000000000000000000000000000000000..c42b691e25f936b65bfb5fa1907a0f20c7e23cc8 --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Debug/net10.0/Grpc.Net.Client.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:75fe0ec43986ef6e78cf41268728909b9819263273fb1e84146c1c6ef58e0028 +size 359520 diff --git a/src/RoslynStone.AppHost/bin/Debug/net10.0/Humanizer.dll b/src/RoslynStone.AppHost/bin/Debug/net10.0/Humanizer.dll new file mode 100644 index 0000000000000000000000000000000000000000..f548e45964c96f10e6e84d6d3938cd42d9b69d11 --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Debug/net10.0/Humanizer.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d6853075547d7e303efd60354d911a2ff18edba582cda2fa59d91a2e5dcf9e98 +size 355944 diff --git a/src/RoslynStone.AppHost/bin/Debug/net10.0/KubernetesClient.dll b/src/RoslynStone.AppHost/bin/Debug/net10.0/KubernetesClient.dll new file mode 100644 index 0000000000000000000000000000000000000000..ffbde61bec628d0ac1a5c742474d3673d6bce342 --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Debug/net10.0/KubernetesClient.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e07ce6e4672a3d97841fa978105a3ff848d31d6b84d6221df22bb0eccd91b1d9 +size 10459648 diff --git a/src/RoslynStone.AppHost/bin/Debug/net10.0/MessagePack.dll b/src/RoslynStone.AppHost/bin/Debug/net10.0/MessagePack.dll new file mode 100644 index 0000000000000000000000000000000000000000..285a9641de2478d1e4f7caa9a748df970b7a7651 --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Debug/net10.0/MessagePack.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b2c1cc3fc4c262a0f7cfa14f668afc61c1f8b8b460b51d894d6331b63acc14b2 +size 330752 diff --git a/src/RoslynStone.AppHost/bin/Debug/net10.0/Microsoft.Extensions.Http.Diagnostics.dll b/src/RoslynStone.AppHost/bin/Debug/net10.0/Microsoft.Extensions.Http.Diagnostics.dll new file mode 100644 index 0000000000000000000000000000000000000000..65a27be31ff0aeba1ec5151d4d28370337a9e63d --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Debug/net10.0/Microsoft.Extensions.Http.Diagnostics.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1ff7cb02bde97774da270bf0fa69f37e69e3d37387209f50ccbca3486a5cfea5 +size 118304 diff --git a/src/RoslynStone.AppHost/bin/Debug/net10.0/Microsoft.Extensions.Http.Resilience.dll b/src/RoslynStone.AppHost/bin/Debug/net10.0/Microsoft.Extensions.Http.Resilience.dll new file mode 100644 index 0000000000000000000000000000000000000000..b4221161cb5eb743cab7075f45e8ae998589ed92 --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Debug/net10.0/Microsoft.Extensions.Http.Resilience.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:90b298565865406d32bad2668ec83a0750e688fe7f556613e4e4934feca08e7e +size 135200 diff --git a/src/RoslynStone.AppHost/bin/Debug/net10.0/Microsoft.Extensions.Telemetry.dll b/src/RoslynStone.AppHost/bin/Debug/net10.0/Microsoft.Extensions.Telemetry.dll new file mode 100644 index 0000000000000000000000000000000000000000..31aaf306772329ef63c534e26e51ecbb735e142b --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Debug/net10.0/Microsoft.Extensions.Telemetry.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2d3709747883dc1278569c77a0c4570490ef601c7de07de03a9f73390657ebe7 +size 149024 diff --git a/src/RoslynStone.AppHost/bin/Debug/net10.0/Microsoft.VisualStudio.Threading.dll b/src/RoslynStone.AppHost/bin/Debug/net10.0/Microsoft.VisualStudio.Threading.dll new file mode 100644 index 0000000000000000000000000000000000000000..9def915150110f7670f8371952c0f98494f3b994 --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Debug/net10.0/Microsoft.VisualStudio.Threading.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:56c4b77d7206df584d82951b2da595b23777d564763940935e3be61d0ffa355c +size 441912 diff --git a/src/RoslynStone.AppHost/bin/Debug/net10.0/Nerdbank.Streams.dll b/src/RoslynStone.AppHost/bin/Debug/net10.0/Nerdbank.Streams.dll new file mode 100644 index 0000000000000000000000000000000000000000..249f7e21b95cd120fb989e9819a65cc18f0c2f99 --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Debug/net10.0/Nerdbank.Streams.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5fa6175dd3e341a6b82ebd659011b9f80a9b6046da603b7fa4a7ee02600ba983 +size 221880 diff --git a/src/RoslynStone.AppHost/bin/Debug/net10.0/Newtonsoft.Json.dll b/src/RoslynStone.AppHost/bin/Debug/net10.0/Newtonsoft.Json.dll new file mode 100644 index 0000000000000000000000000000000000000000..701a3d2000543c0368a7a92ab3949713c793bbb5 --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Debug/net10.0/Newtonsoft.Json.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a28c251dfe36d881e9e2462e171441b8b0ec156fe3f452602c9149b1b9efe05b +size 723368 diff --git a/src/RoslynStone.AppHost/bin/Debug/net10.0/OpenTelemetry.Exporter.OpenTelemetryProtocol.dll b/src/RoslynStone.AppHost/bin/Debug/net10.0/OpenTelemetry.Exporter.OpenTelemetryProtocol.dll new file mode 100644 index 0000000000000000000000000000000000000000..4814c52962c66ef4208c89406930d942bbe2f6f4 --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Debug/net10.0/OpenTelemetry.Exporter.OpenTelemetryProtocol.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4e1f2a91bd1071f2113b63c3acf8981f3ce469ce21c7cb37257aca35cf43e403 +size 140800 diff --git a/src/RoslynStone.AppHost/bin/Debug/net10.0/OpenTelemetry.dll b/src/RoslynStone.AppHost/bin/Debug/net10.0/OpenTelemetry.dll new file mode 100644 index 0000000000000000000000000000000000000000..c7201f6670f89f4f553e8ea7dc7d451fc6ad3dc8 --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Debug/net10.0/OpenTelemetry.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ff852bebdd3b5b37221e2aa0558cff10c6270602052f2a7592bbf3ccb5d3c760 +size 227328 diff --git a/src/RoslynStone.AppHost/bin/Debug/net10.0/Polly.Core.dll b/src/RoslynStone.AppHost/bin/Debug/net10.0/Polly.Core.dll new file mode 100644 index 0000000000000000000000000000000000000000..70dccd8b2321136f39e777f685d94c15ef4cab40 --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Debug/net10.0/Polly.Core.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e968532e30e5fcbc6ae33064f244fcddf6f1476ab69e1a0ed4e1761d1a922b18 +size 223136 diff --git a/src/RoslynStone.AppHost/bin/Debug/net10.0/StreamJsonRpc.dll b/src/RoslynStone.AppHost/bin/Debug/net10.0/StreamJsonRpc.dll new file mode 100644 index 0000000000000000000000000000000000000000..6e092eeaf736f9681113238cc62265d8d6af6918 --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Debug/net10.0/StreamJsonRpc.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:46256935fae63f9545db4205524c9ce90dadbda80fb1fb6c90391bf64324406d +size 354144 diff --git a/src/RoslynStone.AppHost/bin/Debug/net10.0/YamlDotNet.dll b/src/RoslynStone.AppHost/bin/Debug/net10.0/YamlDotNet.dll new file mode 100644 index 0000000000000000000000000000000000000000..d494c31ebe854ddd041ef329d49e806e2f1386c4 --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Debug/net10.0/YamlDotNet.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:86f873f682c619a0c24e263dcdd15fe027104666641c92f503516671d61edda6 +size 293376 diff --git a/src/RoslynStone.AppHost/bin/Debug/net10.0/runtimes/win/lib/net10.0/System.Diagnostics.EventLog.Messages.dll b/src/RoslynStone.AppHost/bin/Debug/net10.0/runtimes/win/lib/net10.0/System.Diagnostics.EventLog.Messages.dll new file mode 100644 index 0000000000000000000000000000000000000000..1009ed6fc35abe6979334e0832889f8fb4e195fc --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Debug/net10.0/runtimes/win/lib/net10.0/System.Diagnostics.EventLog.Messages.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b7b798826d1bbca2c8b05114874deadfc5b420778c8cc1ced1ea53f76b2b16e1 +size 801040 diff --git a/src/RoslynStone.AppHost/bin/Release/net10.0/Aspire.Hosting.dll b/src/RoslynStone.AppHost/bin/Release/net10.0/Aspire.Hosting.dll new file mode 100644 index 0000000000000000000000000000000000000000..b9dec0d2891d2bda6b7b7a7275c0d9e6af477e5a --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Release/net10.0/Aspire.Hosting.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:882cc06ffa8687a9693ac397a7f7db07e1f60796abbfb41f889aed05f22b19c3 +size 1794080 diff --git a/src/RoslynStone.AppHost/bin/Release/net10.0/Google.Protobuf.dll b/src/RoslynStone.AppHost/bin/Release/net10.0/Google.Protobuf.dll new file mode 100644 index 0000000000000000000000000000000000000000..82d0e209dd1976c5acc0b3ac4effde0532d88353 --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Release/net10.0/Google.Protobuf.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d792b92533fec450d21b9ac9e28b337fe25ac4982380eb932027b5fcc2036bf3 +size 497304 diff --git a/src/RoslynStone.AppHost/bin/Release/net10.0/Grpc.AspNetCore.Server.dll b/src/RoslynStone.AppHost/bin/Release/net10.0/Grpc.AspNetCore.Server.dll new file mode 100644 index 0000000000000000000000000000000000000000..13141ad6e185a08ef9f69c0cdab2fe45e40b1e39 --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Release/net10.0/Grpc.AspNetCore.Server.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:aef8a51b4962e44429138557695acc148a5c5c80304337f247dd4b5ff22759d2 +size 159328 diff --git a/src/RoslynStone.AppHost/bin/Release/net10.0/Grpc.Net.Client.dll b/src/RoslynStone.AppHost/bin/Release/net10.0/Grpc.Net.Client.dll new file mode 100644 index 0000000000000000000000000000000000000000..c42b691e25f936b65bfb5fa1907a0f20c7e23cc8 --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Release/net10.0/Grpc.Net.Client.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:75fe0ec43986ef6e78cf41268728909b9819263273fb1e84146c1c6ef58e0028 +size 359520 diff --git a/src/RoslynStone.AppHost/bin/Release/net10.0/Humanizer.dll b/src/RoslynStone.AppHost/bin/Release/net10.0/Humanizer.dll new file mode 100644 index 0000000000000000000000000000000000000000..f548e45964c96f10e6e84d6d3938cd42d9b69d11 --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Release/net10.0/Humanizer.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d6853075547d7e303efd60354d911a2ff18edba582cda2fa59d91a2e5dcf9e98 +size 355944 diff --git a/src/RoslynStone.AppHost/bin/Release/net10.0/KubernetesClient.dll b/src/RoslynStone.AppHost/bin/Release/net10.0/KubernetesClient.dll new file mode 100644 index 0000000000000000000000000000000000000000..ffbde61bec628d0ac1a5c742474d3673d6bce342 --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Release/net10.0/KubernetesClient.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e07ce6e4672a3d97841fa978105a3ff848d31d6b84d6221df22bb0eccd91b1d9 +size 10459648 diff --git a/src/RoslynStone.AppHost/bin/Release/net10.0/MessagePack.dll b/src/RoslynStone.AppHost/bin/Release/net10.0/MessagePack.dll new file mode 100644 index 0000000000000000000000000000000000000000..285a9641de2478d1e4f7caa9a748df970b7a7651 --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Release/net10.0/MessagePack.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b2c1cc3fc4c262a0f7cfa14f668afc61c1f8b8b460b51d894d6331b63acc14b2 +size 330752 diff --git a/src/RoslynStone.AppHost/bin/Release/net10.0/Microsoft.Extensions.Http.Diagnostics.dll b/src/RoslynStone.AppHost/bin/Release/net10.0/Microsoft.Extensions.Http.Diagnostics.dll new file mode 100644 index 0000000000000000000000000000000000000000..65a27be31ff0aeba1ec5151d4d28370337a9e63d --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Release/net10.0/Microsoft.Extensions.Http.Diagnostics.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1ff7cb02bde97774da270bf0fa69f37e69e3d37387209f50ccbca3486a5cfea5 +size 118304 diff --git a/src/RoslynStone.AppHost/bin/Release/net10.0/Microsoft.Extensions.Http.Resilience.dll b/src/RoslynStone.AppHost/bin/Release/net10.0/Microsoft.Extensions.Http.Resilience.dll new file mode 100644 index 0000000000000000000000000000000000000000..b4221161cb5eb743cab7075f45e8ae998589ed92 --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Release/net10.0/Microsoft.Extensions.Http.Resilience.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:90b298565865406d32bad2668ec83a0750e688fe7f556613e4e4934feca08e7e +size 135200 diff --git a/src/RoslynStone.AppHost/bin/Release/net10.0/Microsoft.Extensions.Telemetry.dll b/src/RoslynStone.AppHost/bin/Release/net10.0/Microsoft.Extensions.Telemetry.dll new file mode 100644 index 0000000000000000000000000000000000000000..31aaf306772329ef63c534e26e51ecbb735e142b --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Release/net10.0/Microsoft.Extensions.Telemetry.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2d3709747883dc1278569c77a0c4570490ef601c7de07de03a9f73390657ebe7 +size 149024 diff --git a/src/RoslynStone.AppHost/bin/Release/net10.0/Microsoft.VisualStudio.Threading.dll b/src/RoslynStone.AppHost/bin/Release/net10.0/Microsoft.VisualStudio.Threading.dll new file mode 100644 index 0000000000000000000000000000000000000000..9def915150110f7670f8371952c0f98494f3b994 --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Release/net10.0/Microsoft.VisualStudio.Threading.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:56c4b77d7206df584d82951b2da595b23777d564763940935e3be61d0ffa355c +size 441912 diff --git a/src/RoslynStone.AppHost/bin/Release/net10.0/Nerdbank.Streams.dll b/src/RoslynStone.AppHost/bin/Release/net10.0/Nerdbank.Streams.dll new file mode 100644 index 0000000000000000000000000000000000000000..249f7e21b95cd120fb989e9819a65cc18f0c2f99 --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Release/net10.0/Nerdbank.Streams.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5fa6175dd3e341a6b82ebd659011b9f80a9b6046da603b7fa4a7ee02600ba983 +size 221880 diff --git a/src/RoslynStone.AppHost/bin/Release/net10.0/Newtonsoft.Json.dll b/src/RoslynStone.AppHost/bin/Release/net10.0/Newtonsoft.Json.dll new file mode 100644 index 0000000000000000000000000000000000000000..701a3d2000543c0368a7a92ab3949713c793bbb5 --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Release/net10.0/Newtonsoft.Json.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a28c251dfe36d881e9e2462e171441b8b0ec156fe3f452602c9149b1b9efe05b +size 723368 diff --git a/src/RoslynStone.AppHost/bin/Release/net10.0/OpenTelemetry.Exporter.OpenTelemetryProtocol.dll b/src/RoslynStone.AppHost/bin/Release/net10.0/OpenTelemetry.Exporter.OpenTelemetryProtocol.dll new file mode 100644 index 0000000000000000000000000000000000000000..4814c52962c66ef4208c89406930d942bbe2f6f4 --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Release/net10.0/OpenTelemetry.Exporter.OpenTelemetryProtocol.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4e1f2a91bd1071f2113b63c3acf8981f3ce469ce21c7cb37257aca35cf43e403 +size 140800 diff --git a/src/RoslynStone.AppHost/bin/Release/net10.0/OpenTelemetry.dll b/src/RoslynStone.AppHost/bin/Release/net10.0/OpenTelemetry.dll new file mode 100644 index 0000000000000000000000000000000000000000..c7201f6670f89f4f553e8ea7dc7d451fc6ad3dc8 --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Release/net10.0/OpenTelemetry.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ff852bebdd3b5b37221e2aa0558cff10c6270602052f2a7592bbf3ccb5d3c760 +size 227328 diff --git a/src/RoslynStone.AppHost/bin/Release/net10.0/Polly.Core.dll b/src/RoslynStone.AppHost/bin/Release/net10.0/Polly.Core.dll new file mode 100644 index 0000000000000000000000000000000000000000..70dccd8b2321136f39e777f685d94c15ef4cab40 --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Release/net10.0/Polly.Core.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e968532e30e5fcbc6ae33064f244fcddf6f1476ab69e1a0ed4e1761d1a922b18 +size 223136 diff --git a/src/RoslynStone.AppHost/bin/Release/net10.0/StreamJsonRpc.dll b/src/RoslynStone.AppHost/bin/Release/net10.0/StreamJsonRpc.dll new file mode 100644 index 0000000000000000000000000000000000000000..6e092eeaf736f9681113238cc62265d8d6af6918 --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Release/net10.0/StreamJsonRpc.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:46256935fae63f9545db4205524c9ce90dadbda80fb1fb6c90391bf64324406d +size 354144 diff --git a/src/RoslynStone.AppHost/bin/Release/net10.0/YamlDotNet.dll b/src/RoslynStone.AppHost/bin/Release/net10.0/YamlDotNet.dll new file mode 100644 index 0000000000000000000000000000000000000000..d494c31ebe854ddd041ef329d49e806e2f1386c4 --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Release/net10.0/YamlDotNet.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:86f873f682c619a0c24e263dcdd15fe027104666641c92f503516671d61edda6 +size 293376 diff --git a/src/RoslynStone.AppHost/bin/Release/net10.0/runtimes/win/lib/net10.0/System.Diagnostics.EventLog.Messages.dll b/src/RoslynStone.AppHost/bin/Release/net10.0/runtimes/win/lib/net10.0/System.Diagnostics.EventLog.Messages.dll new file mode 100644 index 0000000000000000000000000000000000000000..1009ed6fc35abe6979334e0832889f8fb4e195fc --- /dev/null +++ b/src/RoslynStone.AppHost/bin/Release/net10.0/runtimes/win/lib/net10.0/System.Diagnostics.EventLog.Messages.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b7b798826d1bbca2c8b05114874deadfc5b420778c8cc1ced1ea53f76b2b16e1 +size 801040 diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..44bb961d90aa1349e3d3f326121830b0a2588ef9 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"fastapi._compat","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","BaseConfig":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.v2.BaseConfig","kind":"Gdef"},"CoreSchema":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.v1.CoreSchema","kind":"Gdef"},"GetJsonSchemaHandler":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.v1.GetJsonSchemaHandler","kind":"Gdef"},"JsonSchemaValue":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.v1.JsonSchemaValue","kind":"Gdef"},"ModelField":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.model_field.ModelField","kind":"Gdef"},"PYDANTIC_V2":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.shared.PYDANTIC_V2","kind":"Gdef"},"PYDANTIC_VERSION_MINOR_TUPLE":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.shared.PYDANTIC_VERSION_MINOR_TUPLE","kind":"Gdef"},"PydanticSchemaGenerationError":{".class":"SymbolTableNode","cross_ref":"pydantic.errors.PydanticSchemaGenerationError","kind":"Gdef"},"RequiredParam":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.v2.RequiredParam","kind":"Gdef"},"Undefined":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.v2.Undefined","kind":"Gdef"},"UndefinedType":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.v2.UndefinedType","kind":"Gdef"},"Url":{".class":"SymbolTableNode","cross_ref":"pydantic_core._pydantic_core.Url","kind":"Gdef"},"Validator":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.v2.Validator","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_get_model_config":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main._get_model_config","kind":"Gdef"},"_is_error_wrapper":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main._is_error_wrapper","kind":"Gdef"},"_is_model_class":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main._is_model_class","kind":"Gdef"},"_is_model_field":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main._is_model_field","kind":"Gdef"},"_is_undefined":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main._is_undefined","kind":"Gdef"},"_model_dump":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main._model_dump","kind":"Gdef"},"_model_rebuild":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main._model_rebuild","kind":"Gdef"},"_normalize_errors":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.may_v1._normalize_errors","kind":"Gdef"},"annotation_is_pydantic_v1":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.shared.annotation_is_pydantic_v1","kind":"Gdef"},"copy_field_info":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main.copy_field_info","kind":"Gdef"},"create_body_model":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main.create_body_model","kind":"Gdef"},"evaluate_forwardref":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.v2.evaluate_forwardref","kind":"Gdef"},"field_annotation_is_scalar":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.shared.field_annotation_is_scalar","kind":"Gdef"},"get_annotation_from_field_info":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main.get_annotation_from_field_info","kind":"Gdef"},"get_cached_model_fields":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main.get_cached_model_fields","kind":"Gdef"},"get_compat_model_name_map":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main.get_compat_model_name_map","kind":"Gdef"},"get_definitions":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main.get_definitions","kind":"Gdef"},"get_missing_field_error":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.v2.get_missing_field_error","kind":"Gdef"},"get_schema_from_model_field":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main.get_schema_from_model_field","kind":"Gdef"},"is_bytes_field":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main.is_bytes_field","kind":"Gdef"},"is_bytes_sequence_field":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main.is_bytes_sequence_field","kind":"Gdef"},"is_scalar_field":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main.is_scalar_field","kind":"Gdef"},"is_scalar_sequence_field":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main.is_scalar_sequence_field","kind":"Gdef"},"is_sequence_field":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main.is_sequence_field","kind":"Gdef"},"is_uploadfile_or_nonable_uploadfile_annotation":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.shared.is_uploadfile_or_nonable_uploadfile_annotation","kind":"Gdef"},"is_uploadfile_sequence_annotation":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.shared.is_uploadfile_sequence_annotation","kind":"Gdef"},"lenient_issubclass":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.shared.lenient_issubclass","kind":"Gdef"},"sequence_types":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.shared.sequence_types","kind":"Gdef"},"serialize_sequence_value":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main.serialize_sequence_value","kind":"Gdef"},"value_is_sequence":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.shared.value_is_sequence","kind":"Gdef"},"with_info_plain_validator_function":{".class":"SymbolTableNode","cross_ref":"pydantic_core.core_schema.with_info_plain_validator_function","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/_compat/__init__.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..6eaa2b70a7569f5aa095b817572a666c4e774457 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,33,37,38,1,1,1,1],"dep_prios":[5,5,5,5,5,30,30,30],"dependencies":["fastapi._compat.main","fastapi._compat.may_v1","fastapi._compat.model_field","fastapi._compat.shared","builtins","_frozen_importlib","abc","typing"],"hash":"0f952d4d5ef9c784999afbcd4026a3a22947edff","id":"fastapi._compat","ignore_all":true,"interface_hash":"feca030e17ad91272e53f57e47dbe021a18806ee","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/_compat/__init__.py","plugin_data":null,"size":2718,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/main.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/main.data.json new file mode 100644 index 0000000000000000000000000000000000000000..7818fa196fddea8d3e59f437809d4944eb8c4493 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/main.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"fastapi._compat.main","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseConfig":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.v2.BaseConfig","kind":"Gdef"},"BaseModel":{".class":"SymbolTableNode","cross_ref":"pydantic.main.BaseModel","kind":"Gdef"},"Dict":{".class":"SymbolTableNode","cross_ref":"typing.Dict","kind":"Gdef"},"FieldInfo":{".class":"SymbolTableNode","cross_ref":"pydantic.fields.FieldInfo","kind":"Gdef"},"List":{".class":"SymbolTableNode","cross_ref":"typing.List","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Literal","kind":"Gdef"},"ModelField":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.model_field.ModelField","kind":"Gdef"},"ModelNameMap":{".class":"SymbolTableNode","cross_ref":"fastapi.types.ModelNameMap","kind":"Gdef"},"PYDANTIC_V2":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.shared.PYDANTIC_V2","kind":"Gdef"},"PydanticSchemaGenerationError":{".class":"SymbolTableNode","cross_ref":"pydantic.errors.PydanticSchemaGenerationError","kind":"Gdef"},"RequiredParam":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.v2.RequiredParam","kind":"Gdef"},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef"},"Tuple":{".class":"SymbolTableNode","cross_ref":"typing.Tuple","kind":"Gdef"},"Type":{".class":"SymbolTableNode","cross_ref":"typing.Type","kind":"Gdef"},"Undefined":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.v2.Undefined","kind":"Gdef"},"UndefinedType":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.v2.UndefinedType","kind":"Gdef"},"Url":{".class":"SymbolTableNode","cross_ref":"pydantic_core._pydantic_core.Url","kind":"Gdef"},"Validator":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.v2.Validator","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.main.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.main.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.main.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.main.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.main.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.main.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_get_model_config":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["model"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.main._get_model_config","name":"_get_model_config","original_first_arg":"model","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["model"],"arg_types":["pydantic.main.BaseModel"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_model_config","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_is_error_wrapper":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["exc"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.main._is_error_wrapper","name":"_is_error_wrapper","original_first_arg":"exc","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["exc"],"arg_types":["builtins.Exception"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_is_error_wrapper","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_is_model_class":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["value"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.main._is_model_class","name":"_is_model_class","original_first_arg":"value","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["value"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_is_model_class","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_is_model_field":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["value"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.main._is_model_field","name":"_is_model_field","original_first_arg":"value","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["value"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_is_model_field","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_is_undefined":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["value"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.main._is_undefined","name":"_is_undefined","original_first_arg":"value","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["value"],"arg_types":["builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_is_undefined","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_model_dump":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,4],"arg_names":["model","mode","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.main._model_dump","name":"_model_dump","original_first_arg":"model","type":{".class":"CallableType","arg_kinds":[0,1,4],"arg_names":["model","mode","kwargs"],"arg_types":["pydantic.main.BaseModel",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"json"},{".class":"LiteralType","fallback":"builtins.str","value":"python"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_model_dump","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_model_rebuild":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["model"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.main._model_rebuild","name":"_model_rebuild","original_first_arg":"model","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["model"],"arg_types":[{".class":"TypeType","item":"pydantic.main.BaseModel"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_model_rebuild","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"copy_field_info":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3],"arg_names":["field_info","annotation"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.main.copy_field_info","name":"copy_field_info","original_first_arg":"field_info","type":{".class":"CallableType","arg_kinds":[3,3],"arg_names":["field_info","annotation"],"arg_types":["pydantic.fields.FieldInfo",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"copy_field_info","ret_type":"pydantic.fields.FieldInfo","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"create_body_model":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3],"arg_names":["fields","model_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.main.create_body_model","name":"create_body_model","original_first_arg":"fields","type":{".class":"CallableType","arg_kinds":[3,3],"arg_names":["fields","model_name"],"arg_types":[{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"typing.Sequence"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"create_body_model","ret_type":{".class":"TypeType","item":"pydantic.main.BaseModel"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"evaluate_forwardref":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.v2.evaluate_forwardref","kind":"Gdef"},"get_annotation_from_field_info":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["annotation","field_info","field_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.main.get_annotation_from_field_info","name":"get_annotation_from_field_info","original_first_arg":"annotation","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["annotation","field_info","field_name"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"pydantic.fields.FieldInfo","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_annotation_from_field_info","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_cached_model_fields":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["model"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated"],"fullname":"fastapi._compat.main.get_cached_model_fields","name":"get_cached_model_fields","original_first_arg":"model","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["model"],"arg_types":[{".class":"TypeType","item":"pydantic.main.BaseModel"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_cached_model_fields","ret_type":{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"fastapi._compat.main.get_cached_model_fields","name":"get_cached_model_fields","setter_type":null,"type":{".class":"Instance","args":[{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"functools._lru_cache_wrapper"}}}},"get_compat_model_name_map":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["fields"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.main.get_compat_model_name_map","name":"get_compat_model_name_map","original_first_arg":"fields","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["fields"],"arg_types":[{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_compat_model_name_map","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"fastapi.types.ModelNameMap"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_definitions":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3,5],"arg_names":["fields","model_name_map","separate_input_output_schemas"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.main.get_definitions","name":"get_definitions","original_first_arg":"fields","type":{".class":"CallableType","arg_kinds":[3,3,5],"arg_names":["fields","model_name_map","separate_input_output_schemas"],"arg_types":[{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"TypeAliasType","args":[],"type_ref":"fastapi.types.ModelNameMap"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_definitions","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["fastapi._compat.model_field.ModelField",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"validation"},{".class":"LiteralType","fallback":"builtins.str","value":"serialization"}],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TypeAliasType","args":[],"type_ref":"fastapi._compat.v1.JsonSchemaValue"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"extra_attrs":null,"type_ref":"builtins.dict"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_missing_field_error":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.v2.get_missing_field_error","kind":"Gdef"},"get_schema_from_model_field":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3,3,5],"arg_names":["field","model_name_map","field_mapping","separate_input_output_schemas"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.main.get_schema_from_model_field","name":"get_schema_from_model_field","original_first_arg":"field","type":{".class":"CallableType","arg_kinds":[3,3,3,5],"arg_names":["field","model_name_map","field_mapping","separate_input_output_schemas"],"arg_types":["fastapi._compat.model_field.ModelField",{".class":"TypeAliasType","args":[],"type_ref":"fastapi.types.ModelNameMap"},{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["fastapi._compat.model_field.ModelField",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"validation"},{".class":"LiteralType","fallback":"builtins.str","value":"serialization"}],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TypeAliasType","args":[],"type_ref":"fastapi._compat.v1.JsonSchemaValue"}],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_schema_from_model_field","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_bytes_field":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["field"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.main.is_bytes_field","name":"is_bytes_field","original_first_arg":"field","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["field"],"arg_types":["fastapi._compat.model_field.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_bytes_field","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_bytes_sequence_field":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["field"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.main.is_bytes_sequence_field","name":"is_bytes_sequence_field","original_first_arg":"field","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["field"],"arg_types":["fastapi._compat.model_field.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_bytes_sequence_field","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_scalar_field":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["field"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.main.is_scalar_field","name":"is_scalar_field","original_first_arg":"field","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["field"],"arg_types":["fastapi._compat.model_field.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_scalar_field","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_scalar_sequence_field":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["field"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.main.is_scalar_sequence_field","name":"is_scalar_sequence_field","original_first_arg":"field","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["field"],"arg_types":["fastapi._compat.model_field.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_scalar_sequence_field","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_sequence_field":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["field"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.main.is_sequence_field","name":"is_sequence_field","original_first_arg":"field","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["field"],"arg_types":["fastapi._compat.model_field.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_sequence_field","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"lenient_issubclass":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.shared.lenient_issubclass","kind":"Gdef"},"lru_cache":{".class":"SymbolTableNode","cross_ref":"functools.lru_cache","kind":"Gdef"},"may_v1":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.may_v1","kind":"Gdef"},"serialize_sequence_value":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3],"arg_names":["field","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.main.serialize_sequence_value","name":"serialize_sequence_value","original_first_arg":"field","type":{".class":"CallableType","arg_kinds":[3,3],"arg_names":["field","value"],"arg_types":["fastapi._compat.model_field.ModelField",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"serialize_sequence_value","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Sequence"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"sys":{".class":"SymbolTableNode","cross_ref":"sys","kind":"Gdef"},"with_info_plain_validator_function":{".class":"SymbolTableNode","cross_ref":"pydantic_core.core_schema.with_info_plain_validator_function","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/_compat/main.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/main.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/main.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..b9198db1faa208a296d19b7574d1eb1938e6092c --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/main.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[12,13,18,21,35,12,14,1,2,3,15,16,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],"dep_prios":[10,5,5,5,5,20,5,10,5,5,5,5,5,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30],"dependencies":["fastapi._compat.may_v1","fastapi._compat.shared","fastapi._compat.model_field","fastapi._compat.v2","fastapi._compat.v1","fastapi._compat","fastapi.types","sys","functools","typing","pydantic","typing_extensions","builtins","_frozen_importlib","_typeshed","abc","enum","pydantic._internal","pydantic._internal._model_construction","pydantic._internal._repr","pydantic._internal._typing_extra","pydantic.deprecated","pydantic.deprecated.config","pydantic.errors","pydantic.fields","pydantic.main","pydantic.networks","pydantic_core","pydantic_core._pydantic_core","pydantic_core.core_schema"],"hash":"118bf0c92c8dd41fc40428296b808ba1f5592895","id":"fastapi._compat.main","ignore_all":true,"interface_hash":"302585e2de6d13461524a05bd6e1fc131dfbeb40","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/_compat/main.py","plugin_data":null,"size":10978,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/may_v1.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/may_v1.data.json new file mode 100644 index 0000000000000000000000000000000000000000..d47d345855d46269bff93bdeb4b46824c05fd0f5 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/may_v1.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"fastapi._compat.may_v1","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"AnyUrl":{".class":"SymbolTableNode","cross_ref":"pydantic.networks.AnyUrl","kind":"Gdef"},"BaseConfig":{".class":"SymbolTableNode","cross_ref":"pydantic.deprecated.config.BaseConfig","kind":"Gdef"},"BaseModel":{".class":"SymbolTableNode","cross_ref":"pydantic.main.BaseModel","kind":"Gdef"},"Color":{".class":"SymbolTableNode","cross_ref":"pydantic.color.Color","kind":"Gdef"},"CoreSchema":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.v1.CoreSchema","kind":"Gdef"},"Dict":{".class":"SymbolTableNode","cross_ref":"typing.Dict","kind":"Gdef"},"ErrorWrapper":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","from_module_getattr"],"fullname":"pydantic.error_wrappers.ErrorWrapper","name":"ErrorWrapper","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"FieldInfo":{".class":"SymbolTableNode","cross_ref":"pydantic.fields.FieldInfo","kind":"Gdef"},"GetJsonSchemaHandler":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.v1.GetJsonSchemaHandler","kind":"Gdef"},"JsonSchemaValue":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.v1.JsonSchemaValue","kind":"Gdef"},"List":{".class":"SymbolTableNode","cross_ref":"typing.List","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"ModelField":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.v1.ModelField","kind":"Gdef"},"ModelNameMap":{".class":"SymbolTableNode","cross_ref":"fastapi.types.ModelNameMap","kind":"Gdef"},"NameEmail":{".class":"SymbolTableNode","cross_ref":"pydantic.networks.NameEmail","kind":"Gdef"},"RequestErrorModel":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"fastapi._compat.may_v1.RequestErrorModel","name":"RequestErrorModel","setter_type":null,"type":{".class":"TypeType","item":"pydantic.main.BaseModel"}}},"RequiredParam":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.v1.RequiredParam","kind":"Gdef"},"SecretBytes":{".class":"SymbolTableNode","cross_ref":"pydantic.types.SecretBytes","kind":"Gdef"},"SecretStr":{".class":"SymbolTableNode","cross_ref":"pydantic.types.SecretStr","kind":"Gdef"},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef"},"Tuple":{".class":"SymbolTableNode","cross_ref":"typing.Tuple","kind":"Gdef"},"Type":{".class":"SymbolTableNode","cross_ref":"typing.Type","kind":"Gdef"},"Undefined":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.v1.Undefined","kind":"Gdef"},"UndefinedType":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.v1.UndefinedType","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"Url":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.v1.Url","kind":"Gdef"},"ValidationError":{".class":"SymbolTableNode","cross_ref":"pydantic.ValidationError","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.may_v1.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.may_v1.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.may_v1.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.may_v1.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.may_v1.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.may_v1.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_normalize_errors":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["errors"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.may_v1._normalize_errors","name":"_normalize_errors","original_first_arg":"errors","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["errors"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_normalize_errors","ret_type":{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_regenerate_error_with_loc":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3],"arg_names":["errors","loc_prefix"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.may_v1._regenerate_error_with_loc","name":"_regenerate_error_with_loc","original_first_arg":"errors","type":{".class":"CallableType","arg_kinds":[3,3],"arg_names":["errors","loc_prefix"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str","builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_regenerate_error_with_loc","ret_type":{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"create_model":{".class":"SymbolTableNode","cross_ref":"pydantic.main.create_model","kind":"Gdef"},"get_definitions":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.v1.get_definitions","kind":"Gdef"},"sys":{".class":"SymbolTableNode","cross_ref":"sys","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/_compat/may_v1.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/may_v1.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/may_v1.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..8a300993f3b177fd9aedb13b17fb96488c6bd0bd --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/may_v1.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[76,4,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1],"dep_prios":[5,5,10,5,5,30,30,30,30,30,30,30,30,30,30,30,30,30],"dependencies":["fastapi._compat.v1","fastapi.types","sys","typing","builtins","_frozen_importlib","_typeshed","abc","pydantic","pydantic._internal","pydantic._internal._generate_schema","pydantic._internal._model_construction","pydantic._internal._repr","pydantic.aliases","pydantic.config","pydantic.fields","pydantic.main","re"],"hash":"f36be568623de37f7cd301bdb2889461b0ff4a5f","id":"fastapi._compat.may_v1","ignore_all":true,"interface_hash":"f562030ecb33b813e42ce0af5f1010578d4a8a72","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/_compat/may_v1.py","plugin_data":null,"size":2979,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/model_field.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/model_field.data.json new file mode 100644 index 0000000000000000000000000000000000000000..3b67a5dbe7096e5a84877c1142a2b658e617f388 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/model_field.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"fastapi._compat.model_field","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"Dict":{".class":"SymbolTableNode","cross_ref":"typing.Dict","kind":"Gdef"},"FieldInfo":{".class":"SymbolTableNode","cross_ref":"pydantic.fields.FieldInfo","kind":"Gdef"},"IncEx":{".class":"SymbolTableNode","cross_ref":"fastapi.types.IncEx","kind":"Gdef"},"List":{".class":"SymbolTableNode","cross_ref":"typing.List","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Literal","kind":"Gdef"},"ModelField":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[["alias",2],["default",2],["field_info",1],["get_default",2],["name",1],["required",2],["serialize",2],["type_",2],["validate",2]],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi._compat.model_field.ModelField","name":"ModelField","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_abstract","is_protocol"],"fullname":"fastapi._compat.model_field.ModelField","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"fastapi._compat.model_field","mro":["fastapi._compat.model_field.ModelField","builtins.object"],"names":{".class":"SymbolTable","_version":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi._compat.model_field.ModelField._version","name":"_version","setter_type":null,"type":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"v1"},{".class":"LiteralType","fallback":"builtins.str","value":"v2"}],"uses_pep604_syntax":false}}},"alias":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_body","is_trivial_self"],"fullname":"fastapi._compat.model_field.ModelField.alias","name":"alias","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi._compat.model_field.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"alias of ModelField","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"fastapi._compat.model_field.ModelField.alias","name":"alias","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi._compat.model_field.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"alias of ModelField","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"default":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_body","is_trivial_self"],"fullname":"fastapi._compat.model_field.ModelField.default","name":"default","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi._compat.model_field.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"default of ModelField","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"fastapi._compat.model_field.ModelField.default","name":"default","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi._compat.model_field.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"default of ModelField","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"field_info":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_abstract_var","is_ready"],"fullname":"fastapi._compat.model_field.ModelField.field_info","name":"field_info","setter_type":null,"type":"pydantic.fields.FieldInfo"}},"get_default":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_body","is_trivial_self"],"fullname":"fastapi._compat.model_field.ModelField.get_default","name":"get_default","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi._compat.model_field.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_default of ModelField","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"mode":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi._compat.model_field.ModelField.mode","name":"mode","setter_type":null,"type":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"validation"},{".class":"LiteralType","fallback":"builtins.str","value":"serialization"}],"uses_pep604_syntax":false}}},"name":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_abstract_var","is_ready"],"fullname":"fastapi._compat.model_field.ModelField.name","name":"name","setter_type":null,"type":"builtins.str"}},"required":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_body","is_trivial_self"],"fullname":"fastapi._compat.model_field.ModelField.required","name":"required","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi._compat.model_field.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"required of ModelField","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"fastapi._compat.model_field.ModelField.required","name":"required","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi._compat.model_field.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"required of ModelField","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"serialize":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0,0,5,5,5,5,5,5,5],"arg_names":["self","value","mode","include","exclude","by_alias","exclude_unset","exclude_defaults","exclude_none"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_body","is_trivial_self"],"fullname":"fastapi._compat.model_field.ModelField.serialize","name":"serialize","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5],"arg_names":["self","value","mode","include","exclude","by_alias","exclude_unset","exclude_defaults","exclude_none"],"arg_types":["fastapi._compat.model_field.ModelField",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"json"},{".class":"LiteralType","fallback":"builtins.str","value":"python"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.types.IncEx"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.types.IncEx"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool","builtins.bool","builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"serialize of ModelField","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"type_":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_body","is_trivial_self"],"fullname":"fastapi._compat.model_field.ModelField.type_","name":"type_","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi._compat.model_field.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"type_ of ModelField","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"fastapi._compat.model_field.ModelField.type_","name":"type_","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi._compat.model_field.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"type_ of ModelField","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"validate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0,0,1,5],"arg_names":["self","value","values","loc"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_body","is_trivial_self"],"fullname":"fastapi._compat.model_field.ModelField.validate","name":"validate","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,5],"arg_names":["self","value","values","loc"],"arg_types":["fastapi._compat.model_field.ModelField",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":[{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate of ModelField","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi._compat.model_field.ModelField.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi._compat.model_field.ModelField","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Protocol":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Protocol","kind":"Gdef"},"Tuple":{".class":"SymbolTableNode","cross_ref":"typing.Tuple","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.model_field.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.model_field.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.model_field.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.model_field.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.model_field.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.model_field.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/_compat/model_field.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/model_field.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/model_field.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..882eea1033998e044956cd18e301126d26e1d286 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/model_field.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[9,10,1,11,1,1,1,1,1,1],"dep_prios":[5,5,5,5,5,30,30,30,30,30],"dependencies":["fastapi.types","pydantic.fields","typing","typing_extensions","builtins","_frozen_importlib","abc","pydantic","pydantic._internal","pydantic._internal._repr"],"hash":"8c0355d58be4d364a2850026052a76cf3227ec6d","id":"fastapi._compat.model_field","ignore_all":true,"interface_hash":"e2f71b97ae56e8a7f47bec92173ceb29bbf68ee6","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/_compat/model_field.py","plugin_data":null,"size":1190,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/shared.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/shared.data.json new file mode 100644 index 0000000000000000000000000000000000000000..8a2acf6e76021647d4221db74ccd922c4c6c491c --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/shared.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"fastapi._compat.shared","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Annotated":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Annotated","kind":"Gdef"},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseModel":{".class":"SymbolTableNode","cross_ref":"pydantic.main.BaseModel","kind":"Gdef"},"Deque":{".class":"SymbolTableNode","cross_ref":"typing.Deque","kind":"Gdef"},"FrozenSet":{".class":"SymbolTableNode","cross_ref":"typing.FrozenSet","kind":"Gdef"},"List":{".class":"SymbolTableNode","cross_ref":"typing.List","kind":"Gdef"},"Mapping":{".class":"SymbolTableNode","cross_ref":"typing.Mapping","kind":"Gdef"},"PYDANTIC_V2":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"fastapi._compat.shared.PYDANTIC_V2","name":"PYDANTIC_V2","setter_type":null,"type":"builtins.bool"}},"PYDANTIC_VERSION":{".class":"SymbolTableNode","cross_ref":"pydantic.version.VERSION","kind":"Gdef"},"PYDANTIC_VERSION_MINOR_TUPLE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"fastapi._compat.shared.PYDANTIC_VERSION_MINOR_TUPLE","name":"PYDANTIC_VERSION_MINOR_TUPLE","setter_type":null,"type":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}}},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef"},"Set":{".class":"SymbolTableNode","cross_ref":"typing.Set","kind":"Gdef"},"Tuple":{".class":"SymbolTableNode","cross_ref":"typing.Tuple","kind":"Gdef"},"Type":{".class":"SymbolTableNode","cross_ref":"typing.Type","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"UnionType":{".class":"SymbolTableNode","cross_ref":"fastapi.types.UnionType","kind":"Gdef"},"UploadFile":{".class":"SymbolTableNode","cross_ref":"starlette.datastructures.UploadFile","kind":"Gdef"},"Url":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.shared.Url","name":"Url","setter_type":null,"type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}}},"WithArgsTypes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"fastapi._compat.shared.WithArgsTypes","name":"WithArgsTypes","setter_type":null,"type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.shared.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.shared.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.shared.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.shared.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.shared.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.shared.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_annotation_is_complex":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["annotation"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.shared._annotation_is_complex","name":"_annotation_is_complex","original_first_arg":"annotation","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["annotation"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_annotation_is_complex","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_annotation_is_sequence":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["annotation"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.shared._annotation_is_sequence","name":"_annotation_is_sequence","original_first_arg":"annotation","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["annotation"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_annotation_is_sequence","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"annotation_is_pydantic_v1":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["annotation"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.shared.annotation_is_pydantic_v1","name":"annotation_is_pydantic_v1","original_first_arg":"annotation","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["annotation"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"annotation_is_pydantic_v1","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"deque":{".class":"SymbolTableNode","cross_ref":"collections.deque","kind":"Gdef"},"field_annotation_is_complex":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["annotation"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.shared.field_annotation_is_complex","name":"field_annotation_is_complex","original_first_arg":"annotation","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["annotation"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"field_annotation_is_complex","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"field_annotation_is_scalar":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["annotation"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.shared.field_annotation_is_scalar","name":"field_annotation_is_scalar","original_first_arg":"annotation","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["annotation"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"field_annotation_is_scalar","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"field_annotation_is_scalar_sequence":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["annotation"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.shared.field_annotation_is_scalar_sequence","name":"field_annotation_is_scalar_sequence","original_first_arg":"annotation","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["annotation"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"field_annotation_is_scalar_sequence","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"field_annotation_is_sequence":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["annotation"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.shared.field_annotation_is_sequence","name":"field_annotation_is_sequence","original_first_arg":"annotation","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["annotation"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"field_annotation_is_sequence","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_args":{".class":"SymbolTableNode","cross_ref":"typing_extensions.get_args","kind":"Gdef"},"get_origin":{".class":"SymbolTableNode","cross_ref":"typing_extensions.get_origin","kind":"Gdef"},"is_bytes_or_nonable_bytes_annotation":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["annotation"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.shared.is_bytes_or_nonable_bytes_annotation","name":"is_bytes_or_nonable_bytes_annotation","original_first_arg":"annotation","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["annotation"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_bytes_or_nonable_bytes_annotation","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_bytes_sequence_annotation":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["annotation"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.shared.is_bytes_sequence_annotation","name":"is_bytes_sequence_annotation","original_first_arg":"annotation","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["annotation"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_bytes_sequence_annotation","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_dataclass":{".class":"SymbolTableNode","cross_ref":"dataclasses.is_dataclass","kind":"Gdef"},"is_uploadfile_or_nonable_uploadfile_annotation":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["annotation"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.shared.is_uploadfile_or_nonable_uploadfile_annotation","name":"is_uploadfile_or_nonable_uploadfile_annotation","original_first_arg":"annotation","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["annotation"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_uploadfile_or_nonable_uploadfile_annotation","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_uploadfile_sequence_annotation":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["annotation"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.shared.is_uploadfile_sequence_annotation","name":"is_uploadfile_sequence_annotation","original_first_arg":"annotation","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["annotation"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_uploadfile_sequence_annotation","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"lenient_issubclass":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","class_or_tuple"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.shared.lenient_issubclass","name":"lenient_issubclass","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","class_or_tuple"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},{".class":"Instance","args":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lenient_issubclass","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"may_v1":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.may_v1","kind":"Gdef"},"sequence_annotation_to_type":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"fastapi._compat.shared.sequence_annotation_to_type","name":"sequence_annotation_to_type","setter_type":null,"type":{".class":"Instance","args":["builtins.object","abc.ABCMeta"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"sequence_types":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"fastapi._compat.shared.sequence_types","name":"sequence_types","setter_type":null,"type":{".class":"Instance","args":["builtins.object"],"extra_attrs":null,"type_ref":"builtins.tuple"}}},"sys":{".class":"SymbolTableNode","cross_ref":"sys","kind":"Gdef"},"types":{".class":"SymbolTableNode","cross_ref":"types","kind":"Gdef"},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef"},"value_is_sequence":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["value"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.shared.value_is_sequence","name":"value_is_sequence","original_first_arg":"value","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["value"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"value_is_sequence","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/_compat/shared.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/shared.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/shared.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..b9551414f02f3883c337b6f70a10c9fa40099f0d --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/shared.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[19,19,20,22,23,1,2,3,4,5,21,24,1,1,1,1,1],"dep_prios":[10,20,5,5,5,10,10,5,5,5,5,5,5,30,30,30,30],"dependencies":["fastapi._compat.may_v1","fastapi._compat","fastapi.types","pydantic.version","starlette.datastructures","sys","types","typing","collections","dataclasses","pydantic","typing_extensions","builtins","_collections_abc","_frozen_importlib","_typeshed","abc"],"hash":"99e97b9ad64e459be5ca15d65342bf246be66e1f","id":"fastapi._compat.shared","ignore_all":true,"interface_hash":"57e76acb1495dd24dded6fa0841cad7023ed638b","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/_compat/shared.py","plugin_data":null,"size":7030,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/v1.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/v1.data.json new file mode 100644 index 0000000000000000000000000000000000000000..3020557271215f6782847d81e3ec332a5333692a --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/v1.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"fastapi._compat.v1","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"AnyUrl":{".class":"SymbolTableNode","cross_ref":"pydantic.networks.AnyUrl","kind":"Gdef"},"BaseConfig":{".class":"SymbolTableNode","cross_ref":"pydantic.deprecated.config.BaseConfig","kind":"Gdef"},"BaseModel":{".class":"SymbolTableNode","cross_ref":"pydantic.main.BaseModel","kind":"Gdef"},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"Color":{".class":"SymbolTableNode","cross_ref":"pydantic.color.Color","kind":"Gdef"},"CoreSchema":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"fastapi._compat.v1.CoreSchema","line":128,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}}},"Dict":{".class":"SymbolTableNode","cross_ref":"typing.Dict","kind":"Gdef"},"Enum":{".class":"SymbolTableNode","cross_ref":"enum.Enum","kind":"Gdef"},"ErrorWrapper":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","from_module_getattr"],"fullname":"pydantic.error_wrappers.ErrorWrapper","name":"ErrorWrapper","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"FieldInfo":{".class":"SymbolTableNode","cross_ref":"pydantic.fields.FieldInfo","kind":"Gdef"},"GenerateJsonSchema":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi._compat.v1.GenerateJsonSchema","name":"GenerateJsonSchema","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi._compat.v1.GenerateJsonSchema","has_param_spec_type":false,"metaclass_type":null,"metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":150,"name":"ref_template","type":"builtins.str"}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi._compat.v1","mro":["fastapi._compat.v1.GenerateJsonSchema","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi._compat.v1.GenerateJsonSchema.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"dataclasses.Field"}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","ref_template"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v1.GenerateJsonSchema.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","ref_template"],"arg_types":["fastapi._compat.v1.GenerateJsonSchema","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of GenerateJsonSchema","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5],"arg_names":["ref_template"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi._compat.v1.GenerateJsonSchema.__mypy-replace","name":"__mypy-replace","original_first_arg":"ref_template","type":{".class":"CallableType","arg_kinds":[5],"arg_names":["ref_template"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of GenerateJsonSchema","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi._compat.v1.GenerateJsonSchema.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5],"arg_names":["ref_template"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of GenerateJsonSchema","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"ref_template":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi._compat.v1.GenerateJsonSchema.ref_template","name":"ref_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi._compat.v1.GenerateJsonSchema.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi._compat.v1.GenerateJsonSchema","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"GetJsonSchemaHandler":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"fastapi._compat.v1.GetJsonSchemaHandler","line":126,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}}},"JsonSchemaValue":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"fastapi._compat.v1.JsonSchemaValue","line":127,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"List":{".class":"SymbolTableNode","cross_ref":"typing.List","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Literal","kind":"Gdef"},"MissingError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","from_module_getattr"],"fullname":"pydantic.errors.MissingError","name":"MissingError","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"ModelField":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"fastapi._compat.v1.ModelField","name":"ModelField","setter_type":null,"type":{".class":"AnyType","missing_import_name":"fastapi._compat.v1.ModelField","source_any":null,"type_of_any":3}}},"ModelNameMap":{".class":"SymbolTableNode","cross_ref":"fastapi.types.ModelNameMap","kind":"Gdef"},"NameEmail":{".class":"SymbolTableNode","cross_ref":"pydantic.networks.NameEmail","kind":"Gdef"},"PYDANTIC_V2":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"fastapi._compat.v1.PYDANTIC_V2","name":"PYDANTIC_V2","setter_type":null,"type":"builtins.bool"}},"PYDANTIC_VERSION":{".class":"SymbolTableNode","cross_ref":"pydantic.version.VERSION","kind":"Gdef"},"PYDANTIC_VERSION_MINOR_TUPLE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"fastapi._compat.v1.PYDANTIC_VERSION_MINOR_TUPLE","name":"PYDANTIC_VERSION_MINOR_TUPLE","setter_type":null,"type":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}}},"PydanticSchemaGenerationError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.Exception"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi._compat.v1.PydanticSchemaGenerationError","name":"PydanticSchemaGenerationError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi._compat.v1.PydanticSchemaGenerationError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"fastapi._compat.v1","mro":["fastapi._compat.v1.PydanticSchemaGenerationError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi._compat.v1.PydanticSchemaGenerationError.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi._compat.v1.PydanticSchemaGenerationError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"REF_PREFIX":{".class":"SymbolTableNode","cross_ref":"fastapi.openapi.constants.REF_PREFIX","kind":"Gdef"},"RequestErrorModel":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"fastapi._compat.v1.RequestErrorModel","name":"RequestErrorModel","setter_type":null,"type":{".class":"TypeType","item":"pydantic.main.BaseModel"}}},"RequiredParam":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"fastapi._compat.v1.RequiredParam","name":"RequiredParam","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"SHAPE_FROZENSET":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"fastapi._compat.v1.SHAPE_FROZENSET","name":"SHAPE_FROZENSET","setter_type":null,"type":{".class":"AnyType","missing_import_name":"fastapi._compat.v1.SHAPE_FROZENSET","source_any":null,"type_of_any":3}}},"SHAPE_LIST":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"fastapi._compat.v1.SHAPE_LIST","name":"SHAPE_LIST","setter_type":null,"type":{".class":"AnyType","missing_import_name":"fastapi._compat.v1.SHAPE_LIST","source_any":null,"type_of_any":3}}},"SHAPE_SEQUENCE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"fastapi._compat.v1.SHAPE_SEQUENCE","name":"SHAPE_SEQUENCE","setter_type":null,"type":{".class":"AnyType","missing_import_name":"fastapi._compat.v1.SHAPE_SEQUENCE","source_any":null,"type_of_any":3}}},"SHAPE_SET":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"fastapi._compat.v1.SHAPE_SET","name":"SHAPE_SET","setter_type":null,"type":{".class":"AnyType","missing_import_name":"fastapi._compat.v1.SHAPE_SET","source_any":null,"type_of_any":3}}},"SHAPE_SINGLETON":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"fastapi._compat.v1.SHAPE_SINGLETON","name":"SHAPE_SINGLETON","setter_type":null,"type":{".class":"AnyType","missing_import_name":"fastapi._compat.v1.SHAPE_SINGLETON","source_any":null,"type_of_any":3}}},"SHAPE_TUPLE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"fastapi._compat.v1.SHAPE_TUPLE","name":"SHAPE_TUPLE","setter_type":null,"type":{".class":"AnyType","missing_import_name":"fastapi._compat.v1.SHAPE_TUPLE","source_any":null,"type_of_any":3}}},"SHAPE_TUPLE_ELLIPSIS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"fastapi._compat.v1.SHAPE_TUPLE_ELLIPSIS","name":"SHAPE_TUPLE_ELLIPSIS","setter_type":null,"type":{".class":"AnyType","missing_import_name":"fastapi._compat.v1.SHAPE_TUPLE_ELLIPSIS","source_any":null,"type_of_any":3}}},"SecretBytes":{".class":"SymbolTableNode","cross_ref":"pydantic.types.SecretBytes","kind":"Gdef"},"SecretStr":{".class":"SymbolTableNode","cross_ref":"pydantic.types.SecretStr","kind":"Gdef"},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef"},"Set":{".class":"SymbolTableNode","cross_ref":"typing.Set","kind":"Gdef"},"Tuple":{".class":"SymbolTableNode","cross_ref":"typing.Tuple","kind":"Gdef"},"Type":{".class":"SymbolTableNode","cross_ref":"typing.Type","kind":"Gdef"},"TypeModelSet":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","from_module_getattr"],"fullname":"pydantic.schema.TypeModelSet","name":"TypeModelSet","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"Undefined":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"fastapi._compat.v1.Undefined","name":"Undefined","setter_type":null,"type":{".class":"AnyType","missing_import_name":"fastapi._compat.v1.Undefined","source_any":null,"type_of_any":3}}},"UndefinedType":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"fastapi._compat.v1.UndefinedType","name":"UndefinedType","setter_type":null,"type":{".class":"AnyType","missing_import_name":"fastapi._compat.v1.UndefinedType","source_any":null,"type_of_any":3}}},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"Url":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"fastapi._compat.v1.Url","line":129,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":"pydantic.networks.AnyUrl"}},"ValidationError":{".class":"SymbolTableNode","cross_ref":"pydantic.ValidationError","kind":"Gdef"},"Validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","from_module_getattr"],"fullname":"pydantic.class_validators.Validator","name":"Validator","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.v1.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.v1.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.v1.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.v1.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.v1.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.v1.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_get_model_config":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["model"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v1._get_model_config","name":"_get_model_config","original_first_arg":"model","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["model"],"arg_types":["pydantic.main.BaseModel"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_model_config","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_model_dump":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,4],"arg_names":["model","mode","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v1._model_dump","name":"_model_dump","original_first_arg":"model","type":{".class":"CallableType","arg_kinds":[0,1,4],"arg_names":["model","mode","kwargs"],"arg_types":["pydantic.main.BaseModel",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"json"},{".class":"LiteralType","fallback":"builtins.str","value":"python"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_model_dump","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_model_rebuild":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["model"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v1._model_rebuild","name":"_model_rebuild","original_first_arg":"model","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["model"],"arg_types":[{".class":"TypeType","item":"pydantic.main.BaseModel"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_model_rebuild","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"copy":{".class":"SymbolTableNode","cross_ref":"copy.copy","kind":"Gdef"},"copy_field_info":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3],"arg_names":["field_info","annotation"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v1.copy_field_info","name":"copy_field_info","original_first_arg":"field_info","type":{".class":"CallableType","arg_kinds":[3,3],"arg_names":["field_info","annotation"],"arg_types":["pydantic.fields.FieldInfo",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"copy_field_info","ret_type":"pydantic.fields.FieldInfo","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"create_body_model":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3],"arg_names":["fields","model_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v1.create_body_model","name":"create_body_model","original_first_arg":"fields","type":{".class":"CallableType","arg_kinds":[3,3],"arg_names":["fields","model_name"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"fastapi._compat.v1.ModelField","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"create_body_model","ret_type":{".class":"TypeType","item":"pydantic.main.BaseModel"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"create_model":{".class":"SymbolTableNode","cross_ref":"pydantic.main.create_model","kind":"Gdef"},"dataclass":{".class":"SymbolTableNode","cross_ref":"dataclasses.dataclass","kind":"Gdef"},"evaluate_forwardref":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","from_module_getattr"],"fullname":"pydantic.typing.evaluate_forwardref","name":"evaluate_forwardref","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"field_schema":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","from_module_getattr"],"fullname":"pydantic.schema.field_schema","name":"field_schema","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"get_annotation_from_field_info":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","from_module_getattr"],"fullname":"pydantic.schema.get_annotation_from_field_info","name":"get_annotation_from_field_info","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"get_definitions":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3,5],"arg_names":["fields","model_name_map","separate_input_output_schemas"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v1.get_definitions","name":"get_definitions","original_first_arg":"fields","type":{".class":"CallableType","arg_kinds":[3,3,5],"arg_names":["fields","model_name_map","separate_input_output_schemas"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"fastapi._compat.v1.ModelField","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"TypeAliasType","args":[],"type_ref":"fastapi.types.ModelNameMap"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_definitions","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"fastapi._compat.v1.ModelField","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"validation"},{".class":"LiteralType","fallback":"builtins.str","value":"serialization"}],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TypeAliasType","args":[],"type_ref":"fastapi._compat.v1.JsonSchemaValue"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"extra_attrs":null,"type_ref":"builtins.dict"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_flat_models_from_field":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","from_module_getattr"],"fullname":"pydantic.schema.get_flat_models_from_field","name":"get_flat_models_from_field","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"get_flat_models_from_fields":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","from_module_getattr"],"fullname":"pydantic.schema.get_flat_models_from_fields","name":"get_flat_models_from_fields","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"get_missing_field_error":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["loc"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v1.get_missing_field_error","name":"get_missing_field_error","original_first_arg":"loc","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["loc"],"arg_types":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_missing_field_error","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_model_definitions":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3],"arg_names":["flat_models","model_name_map"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v1.get_model_definitions","name":"get_model_definitions","original_first_arg":"flat_models","type":{".class":"CallableType","arg_kinds":[3,3],"arg_names":["flat_models","model_name_map"],"arg_types":[{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"TypeType","item":"pydantic.main.BaseModel"},{".class":"TypeType","item":"enum.Enum"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"TypeType","item":"pydantic.main.BaseModel"},{".class":"TypeType","item":"enum.Enum"}],"uses_pep604_syntax":false},"builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_model_definitions","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_model_fields":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["model"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v1.get_model_fields","name":"get_model_fields","original_first_arg":"model","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["model"],"arg_types":[{".class":"TypeType","item":"pydantic.main.BaseModel"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_model_fields","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"fastapi._compat.v1.ModelField","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_model_name_map":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","from_module_getattr"],"fullname":"pydantic.schema.get_model_name_map","name":"get_model_name_map","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"get_schema_from_model_field":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3,3,5],"arg_names":["field","model_name_map","field_mapping","separate_input_output_schemas"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v1.get_schema_from_model_field","name":"get_schema_from_model_field","original_first_arg":"field","type":{".class":"CallableType","arg_kinds":[3,3,3,5],"arg_names":["field","model_name_map","field_mapping","separate_input_output_schemas"],"arg_types":[{".class":"AnyType","missing_import_name":"fastapi._compat.v1.ModelField","source_any":null,"type_of_any":3},{".class":"TypeAliasType","args":[],"type_ref":"fastapi.types.ModelNameMap"},{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"fastapi._compat.v1.ModelField","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"validation"},{".class":"LiteralType","fallback":"builtins.str","value":"serialization"}],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TypeAliasType","args":[],"type_ref":"fastapi._compat.v1.JsonSchemaValue"}],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_schema_from_model_field","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_bytes_field":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["field"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v1.is_bytes_field","name":"is_bytes_field","original_first_arg":"field","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["field"],"arg_types":[{".class":"AnyType","missing_import_name":"fastapi._compat.v1.ModelField","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_bytes_field","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_bytes_sequence_field":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["field"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v1.is_bytes_sequence_field","name":"is_bytes_sequence_field","original_first_arg":"field","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["field"],"arg_types":[{".class":"AnyType","missing_import_name":"fastapi._compat.v1.ModelField","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_bytes_sequence_field","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_dataclass":{".class":"SymbolTableNode","cross_ref":"dataclasses.is_dataclass","kind":"Gdef"},"is_pv1_scalar_field":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["field"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v1.is_pv1_scalar_field","name":"is_pv1_scalar_field","original_first_arg":"field","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["field"],"arg_types":[{".class":"AnyType","missing_import_name":"fastapi._compat.v1.ModelField","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_pv1_scalar_field","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_pv1_scalar_sequence_field":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["field"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v1.is_pv1_scalar_sequence_field","name":"is_pv1_scalar_sequence_field","original_first_arg":"field","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["field"],"arg_types":[{".class":"AnyType","missing_import_name":"fastapi._compat.v1.ModelField","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_pv1_scalar_sequence_field","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_scalar_field":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["field"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v1.is_scalar_field","name":"is_scalar_field","original_first_arg":"field","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["field"],"arg_types":[{".class":"AnyType","missing_import_name":"fastapi._compat.v1.ModelField","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_scalar_field","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_scalar_sequence_field":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["field"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v1.is_scalar_sequence_field","name":"is_scalar_sequence_field","original_first_arg":"field","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["field"],"arg_types":[{".class":"AnyType","missing_import_name":"fastapi._compat.v1.ModelField","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_scalar_sequence_field","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_sequence_field":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["field"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v1.is_sequence_field","name":"is_sequence_field","original_first_arg":"field","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["field"],"arg_types":[{".class":"AnyType","missing_import_name":"fastapi._compat.v1.ModelField","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_sequence_field","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"lenient_issubclass":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","from_module_getattr"],"fullname":"pydantic.utils.lenient_issubclass","name":"lenient_issubclass","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"model_process_schema":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","from_module_getattr"],"fullname":"pydantic.schema.model_process_schema","name":"model_process_schema","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"sequence_shape_to_type":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"fastapi._compat.v1.sequence_shape_to_type","name":"sequence_shape_to_type","setter_type":null,"type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"fastapi._compat.v1.SHAPE_LIST","source_any":null,"type_of_any":3},"abc.ABCMeta"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"sequence_shapes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"fastapi._compat.v1.sequence_shapes","name":"sequence_shapes","setter_type":null,"type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"fastapi._compat.v1.SHAPE_LIST","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.set"}}},"serialize_sequence_value":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3],"arg_names":["field","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v1.serialize_sequence_value","name":"serialize_sequence_value","original_first_arg":"field","type":{".class":"CallableType","arg_kinds":[3,3],"arg_names":["field","value"],"arg_types":[{".class":"AnyType","missing_import_name":"fastapi._compat.v1.ModelField","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"serialize_sequence_value","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Sequence"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"shared":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.shared","kind":"Gdef"},"with_info_plain_validator_function":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5],"arg_names":["function","ref","metadata","serialization"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v1.with_info_plain_validator_function","name":"with_info_plain_validator_function","original_first_arg":"function","type":{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":["function","ref","metadata","serialization"],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"with_info_plain_validator_function","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/_compat/v1.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/v1.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/v1.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..cf66d3016865b96ddcab2120e31d40dbae19e7e3 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/v1.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[16,17,80,81,82,83,84,97,101,116,122,123,16,18,19,33,34,35,36,37,52,54,67,69,70,74,1,2,3,4,20,29,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],"dep_prios":[10,5,5,5,5,5,5,5,5,5,5,5,20,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30],"dependencies":["fastapi._compat.shared","fastapi.openapi.constants","pydantic.v1.class_validators","pydantic.v1.color","pydantic.v1.error_wrappers","pydantic.v1.errors","pydantic.v1.fields","pydantic.v1.networks","pydantic.v1.schema","pydantic.v1.types","pydantic.v1.typing","pydantic.v1.utils","fastapi._compat","fastapi.types","pydantic.version","pydantic.class_validators","pydantic.color","pydantic.error_wrappers","pydantic.errors","pydantic.fields","pydantic.networks","pydantic.schema","pydantic.types","pydantic.typing","pydantic.utils","pydantic.v1","copy","dataclasses","enum","typing","typing_extensions","pydantic","builtins","_frozen_importlib","_typeshed","abc","annotated_types","pydantic._internal","pydantic._internal._generate_schema","pydantic._internal._model_construction","pydantic._internal._repr","pydantic.aliases","pydantic.config","pydantic.deprecated","pydantic.deprecated.config","pydantic.main","pydantic.v1.config","pydantic.v1.dataclasses","pydantic.v1.main","pydantic_core","pydantic_core._pydantic_core","re"],"hash":"4ec1f7a680953227238ef07a006565af66ee5c3d","id":"fastapi._compat.v1","ignore_all":true,"interface_hash":"12cb402c9f025b3dc9f7799a43d45b6a2fbe9c80","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/_compat/v1.py","plugin_data":null,"size":10325,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/v2.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/v2.data.json new file mode 100644 index 0000000000000000000000000000000000000000..a5fee0eaeb66c44c11d5123eeeeaffa0b3e1a24b --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/v2.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"fastapi._compat.v2","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Annotated":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Annotated","kind":"Gdef"},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseConfig":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi._compat.v2.BaseConfig","name":"BaseConfig","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi._compat.v2.BaseConfig","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"fastapi._compat.v2","mro":["fastapi._compat.v2.BaseConfig","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi._compat.v2.BaseConfig.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi._compat.v2.BaseConfig","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"BaseModel":{".class":"SymbolTableNode","cross_ref":"pydantic.main.BaseModel","kind":"Gdef"},"CoreSchema":{".class":"SymbolTableNode","cross_ref":"pydantic_core.core_schema.CoreSchema","kind":"Gdef"},"Dict":{".class":"SymbolTableNode","cross_ref":"typing.Dict","kind":"Gdef"},"Enum":{".class":"SymbolTableNode","cross_ref":"enum.Enum","kind":"Gdef"},"ErrorWrapper":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.Exception"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi._compat.v2.ErrorWrapper","name":"ErrorWrapper","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi._compat.v2.ErrorWrapper","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"fastapi._compat.v2","mro":["fastapi._compat.v2.ErrorWrapper","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi._compat.v2.ErrorWrapper.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi._compat.v2.ErrorWrapper","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"FieldInfo":{".class":"SymbolTableNode","cross_ref":"pydantic.fields.FieldInfo","kind":"Gdef"},"GenerateJsonSchema":{".class":"SymbolTableNode","cross_ref":"pydantic.json_schema.GenerateJsonSchema","kind":"Gdef"},"GetJsonSchemaHandler":{".class":"SymbolTableNode","cross_ref":"pydantic.annotated_handlers.GetJsonSchemaHandler","kind":"Gdef"},"IncEx":{".class":"SymbolTableNode","cross_ref":"fastapi.types.IncEx","kind":"Gdef"},"JsonSchemaValue":{".class":"SymbolTableNode","cross_ref":"pydantic.json_schema.JsonSchemaValue","kind":"Gdef"},"List":{".class":"SymbolTableNode","cross_ref":"typing.List","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Literal","kind":"Gdef"},"ModelField":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi._compat.v2.ModelField","name":"ModelField","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi._compat.v2.ModelField","has_param_spec_type":false,"metaclass_type":null,"metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":64,"name":"field_info","type":"pydantic.fields.FieldInfo"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":65,"name":"name","type":"builtins.str"},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":66,"name":"mode","type":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"validation"},{".class":"LiteralType","fallback":"builtins.str","value":"serialization"}],"uses_pep604_syntax":false}}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi._compat.v2","mro":["fastapi._compat.v2.ModelField","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi._compat.v2.ModelField.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"dataclasses.Field"}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__hash__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"fastapi._compat.v2.ModelField.__hash__","name":"__hash__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi._compat.v2.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__hash__ of ModelField","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","field_info","name","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v2.ModelField.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","field_info","name","mode"],"arg_types":["fastapi._compat.v2.ModelField","pydantic.fields.FieldInfo","builtins.str",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"validation"},{".class":"LiteralType","fallback":"builtins.str","value":"serialization"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of ModelField","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-post_init":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v2.ModelField.__mypy-post_init","name":"__mypy-post_init","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi._compat.v2.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-post_init of ModelField","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5],"arg_names":["field_info","name","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi._compat.v2.ModelField.__mypy-replace","name":"__mypy-replace","original_first_arg":"field_info","type":{".class":"CallableType","arg_kinds":[5,5,5],"arg_names":["field_info","name","mode"],"arg_types":["pydantic.fields.FieldInfo","builtins.str",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"validation"},{".class":"LiteralType","fallback":"builtins.str","value":"serialization"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of ModelField","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi._compat.v2.ModelField.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5],"arg_names":["field_info","name","mode"],"arg_types":["pydantic.fields.FieldInfo","builtins.str",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"validation"},{".class":"LiteralType","fallback":"builtins.str","value":"serialization"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of ModelField","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"__post_init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"fastapi._compat.v2.ModelField.__post_init__","name":"__post_init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi._compat.v2.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__post_init__ of ModelField","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_type_adapter":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"fastapi._compat.v2.ModelField._type_adapter","name":"_type_adapter","setter_type":null,"type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"pydantic.type_adapter.TypeAdapter"}}},"alias":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"fastapi._compat.v2.ModelField.alias","name":"alias","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi._compat.v2.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"alias of ModelField","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"fastapi._compat.v2.ModelField.alias","name":"alias","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi._compat.v2.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"alias of ModelField","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"default":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"fastapi._compat.v2.ModelField.default","name":"default","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi._compat.v2.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"default of ModelField","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"fastapi._compat.v2.ModelField.default","name":"default","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi._compat.v2.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"default of ModelField","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"field_info":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi._compat.v2.ModelField.field_info","name":"field_info","setter_type":null,"type":"pydantic.fields.FieldInfo"}},"get_default":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"fastapi._compat.v2.ModelField.get_default","name":"get_default","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi._compat.v2.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_default of ModelField","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"mode":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi._compat.v2.ModelField.mode","name":"mode","setter_type":null,"type":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"validation"},{".class":"LiteralType","fallback":"builtins.str","value":"serialization"}],"uses_pep604_syntax":false}}},"name":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi._compat.v2.ModelField.name","name":"name","setter_type":null,"type":"builtins.str"}},"required":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"fastapi._compat.v2.ModelField.required","name":"required","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi._compat.v2.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"required of ModelField","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"fastapi._compat.v2.ModelField.required","name":"required","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi._compat.v2.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"required of ModelField","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"serialize":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5,5,5],"arg_names":["self","value","mode","include","exclude","by_alias","exclude_unset","exclude_defaults","exclude_none"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"fastapi._compat.v2.ModelField.serialize","name":"serialize","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5],"arg_names":["self","value","mode","include","exclude","by_alias","exclude_unset","exclude_defaults","exclude_none"],"arg_types":["fastapi._compat.v2.ModelField",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"json"},{".class":"LiteralType","fallback":"builtins.str","value":"python"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.types.IncEx"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.types.IncEx"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool","builtins.bool","builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"serialize of ModelField","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"type_":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"fastapi._compat.v2.ModelField.type_","name":"type_","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi._compat.v2.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"type_ of ModelField","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"fastapi._compat.v2.ModelField.type_","name":"type_","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi._compat.v2.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"type_ of ModelField","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"validate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,5],"arg_names":["self","value","values","loc"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"fastapi._compat.v2.ModelField.validate","name":"validate","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,5],"arg_names":["self","value","values","loc"],"arg_types":["fastapi._compat.v2.ModelField",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":[{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate of ModelField","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi._compat.v2.ModelField.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi._compat.v2.ModelField","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ModelNameMap":{".class":"SymbolTableNode","cross_ref":"fastapi.types.ModelNameMap","kind":"Gdef"},"PydanticSchemaGenerationError":{".class":"SymbolTableNode","cross_ref":"pydantic.errors.PydanticSchemaGenerationError","kind":"Gdef"},"PydanticUndefined":{".class":"SymbolTableNode","cross_ref":"pydantic_core._pydantic_core.PydanticUndefined","kind":"Gdef"},"PydanticUndefinedAnnotation":{".class":"SymbolTableNode","cross_ref":"pydantic.errors.PydanticUndefinedAnnotation","kind":"Gdef"},"PydanticUndefinedType":{".class":"SymbolTableNode","cross_ref":"pydantic_core._pydantic_core.PydanticUndefinedType","kind":"Gdef"},"REF_TEMPLATE":{".class":"SymbolTableNode","cross_ref":"fastapi.openapi.constants.REF_TEMPLATE","kind":"Gdef"},"RequiredParam":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"fastapi._compat.v2.RequiredParam","name":"RequiredParam","setter_type":null,"type":"pydantic_core._pydantic_core.PydanticUndefinedType"}},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef"},"Set":{".class":"SymbolTableNode","cross_ref":"typing.Set","kind":"Gdef"},"Tuple":{".class":"SymbolTableNode","cross_ref":"typing.Tuple","kind":"Gdef"},"Type":{".class":"SymbolTableNode","cross_ref":"typing.Type","kind":"Gdef"},"TypeAdapter":{".class":"SymbolTableNode","cross_ref":"pydantic.type_adapter.TypeAdapter","kind":"Gdef"},"TypeModelOrEnum":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"fastapi._compat.v2.TypeModelOrEnum","line":404,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"TypeType","item":"pydantic.main.BaseModel"},{".class":"TypeType","item":"enum.Enum"}],"uses_pep604_syntax":false}}},"TypeModelSet":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"fastapi._compat.v2.TypeModelSet","line":405,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi._compat.v2.TypeModelOrEnum"}],"extra_attrs":null,"type_ref":"builtins.set"}}},"Undefined":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"fastapi._compat.v2.Undefined","name":"Undefined","setter_type":null,"type":"pydantic_core._pydantic_core.PydanticUndefinedType"}},"UndefinedType":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"fastapi._compat.v2.UndefinedType","line":49,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":"pydantic_core._pydantic_core.PydanticUndefinedType"}},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"Url":{".class":"SymbolTableNode","cross_ref":"pydantic_core._pydantic_core.Url","kind":"Gdef"},"ValidationError":{".class":"SymbolTableNode","cross_ref":"pydantic.ValidationError","kind":"Gdef"},"Validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"fastapi._compat.v2.Validator","line":51,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.v2.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.v2.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.v2.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.v2.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.v2.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi._compat.v2.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_get_model_config":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["model"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v2._get_model_config","name":"_get_model_config","original_first_arg":"model","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["model"],"arg_types":["pydantic.main.BaseModel"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_model_config","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_model_dump":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,4],"arg_names":["model","mode","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v2._model_dump","name":"_model_dump","original_first_arg":"model","type":{".class":"CallableType","arg_kinds":[0,1,4],"arg_names":["model","mode","kwargs"],"arg_types":["pydantic.main.BaseModel",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"json"},{".class":"LiteralType","fallback":"builtins.str","value":"python"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_model_dump","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_model_rebuild":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["model"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v2._model_rebuild","name":"_model_rebuild","original_first_arg":"model","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["model"],"arg_types":[{".class":"TypeType","item":"pydantic.main.BaseModel"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_model_rebuild","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_remap_definitions_and_field_mappings":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3,3],"arg_names":["model_name_map","definitions","field_mapping"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v2._remap_definitions_and_field_mappings","name":"_remap_definitions_and_field_mappings","original_first_arg":"model_name_map","type":{".class":"CallableType","arg_kinds":[3,3,3],"arg_names":["model_name_map","definitions","field_mapping"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.types.ModelNameMap"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["fastapi._compat.v2.ModelField",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"validation"},{".class":"LiteralType","fallback":"builtins.str","value":"serialization"}],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.json_schema.JsonSchemaValue"}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_remap_definitions_and_field_mappings","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["fastapi._compat.v2.ModelField",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"validation"},{".class":"LiteralType","fallback":"builtins.str","value":"serialization"}],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.json_schema.JsonSchemaValue"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_replace_refs":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3],"arg_names":["schema","old_name_to_new_name_map"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v2._replace_refs","name":"_replace_refs","original_first_arg":"schema","type":{".class":"CallableType","arg_kinds":[3,3],"arg_names":["schema","old_name_to_new_name_map"],"arg_types":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_replace_refs","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"cast":{".class":"SymbolTableNode","cross_ref":"typing.cast","kind":"Gdef"},"copy":{".class":"SymbolTableNode","cross_ref":"copy.copy","kind":"Gdef"},"copy_field_info":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3],"arg_names":["field_info","annotation"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v2.copy_field_info","name":"copy_field_info","original_first_arg":"field_info","type":{".class":"CallableType","arg_kinds":[3,3],"arg_names":["field_info","annotation"],"arg_types":["pydantic.fields.FieldInfo",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"copy_field_info","ret_type":"pydantic.fields.FieldInfo","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"create_body_model":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3],"arg_names":["fields","model_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v2.create_body_model","name":"create_body_model","original_first_arg":"fields","type":{".class":"CallableType","arg_kinds":[3,3],"arg_names":["fields","model_name"],"arg_types":[{".class":"Instance","args":["fastapi._compat.v2.ModelField"],"extra_attrs":null,"type_ref":"typing.Sequence"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"create_body_model","ret_type":{".class":"TypeType","item":"pydantic.main.BaseModel"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"create_model":{".class":"SymbolTableNode","cross_ref":"pydantic.main.create_model","kind":"Gdef"},"dataclass":{".class":"SymbolTableNode","cross_ref":"dataclasses.dataclass","kind":"Gdef"},"deepcopy":{".class":"SymbolTableNode","cross_ref":"copy.deepcopy","kind":"Gdef"},"eval_type_lenient":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._typing_extra.eval_type_lenient","kind":"Gdef"},"evaluate_forwardref":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"fastapi._compat.v2.evaluate_forwardref","name":"evaluate_forwardref","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["value","globalns","localns"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.GlobalsNamespace"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_annotation_from_field_info":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["annotation","field_info","field_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v2.get_annotation_from_field_info","name":"get_annotation_from_field_info","original_first_arg":"annotation","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["annotation","field_info","field_name"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"pydantic.fields.FieldInfo","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_annotation_from_field_info","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_args":{".class":"SymbolTableNode","cross_ref":"typing_extensions.get_args","kind":"Gdef"},"get_definitions":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3,5],"arg_names":["fields","model_name_map","separate_input_output_schemas"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v2.get_definitions","name":"get_definitions","original_first_arg":"fields","type":{".class":"CallableType","arg_kinds":[3,3,5],"arg_names":["fields","model_name_map","separate_input_output_schemas"],"arg_types":[{".class":"Instance","args":["fastapi._compat.v2.ModelField"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"TypeAliasType","args":[],"type_ref":"fastapi.types.ModelNameMap"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_definitions","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["fastapi._compat.v2.ModelField",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"validation"},{".class":"LiteralType","fallback":"builtins.str","value":"serialization"}],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.json_schema.JsonSchemaValue"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"extra_attrs":null,"type_ref":"builtins.dict"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_flat_models_from_annotation":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["annotation","known_models"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v2.get_flat_models_from_annotation","name":"get_flat_models_from_annotation","original_first_arg":"annotation","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["annotation","known_models"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeAliasType","args":[],"type_ref":"fastapi._compat.v2.TypeModelSet"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_flat_models_from_annotation","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"fastapi._compat.v2.TypeModelSet"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_flat_models_from_field":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["field","known_models"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v2.get_flat_models_from_field","name":"get_flat_models_from_field","original_first_arg":"field","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["field","known_models"],"arg_types":["fastapi._compat.v2.ModelField",{".class":"TypeAliasType","args":[],"type_ref":"fastapi._compat.v2.TypeModelSet"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_flat_models_from_field","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"fastapi._compat.v2.TypeModelSet"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_flat_models_from_fields":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["fields","known_models"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v2.get_flat_models_from_fields","name":"get_flat_models_from_fields","original_first_arg":"fields","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["fields","known_models"],"arg_types":[{".class":"Instance","args":["fastapi._compat.v2.ModelField"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"TypeAliasType","args":[],"type_ref":"fastapi._compat.v2.TypeModelSet"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_flat_models_from_fields","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"fastapi._compat.v2.TypeModelSet"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_flat_models_from_model":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["model","known_models"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v2.get_flat_models_from_model","name":"get_flat_models_from_model","original_first_arg":"model","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["model","known_models"],"arg_types":[{".class":"TypeType","item":"pydantic.main.BaseModel"},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi._compat.v2.TypeModelSet"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_flat_models_from_model","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"fastapi._compat.v2.TypeModelSet"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_long_model_name":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["model"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v2.get_long_model_name","name":"get_long_model_name","original_first_arg":"model","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["model"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi._compat.v2.TypeModelOrEnum"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_long_model_name","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_missing_field_error":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["loc"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v2.get_missing_field_error","name":"get_missing_field_error","original_first_arg":"loc","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["loc"],"arg_types":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_missing_field_error","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_model_fields":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["model"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v2.get_model_fields","name":"get_model_fields","original_first_arg":"model","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["model"],"arg_types":[{".class":"TypeType","item":"pydantic.main.BaseModel"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_model_fields","ret_type":{".class":"Instance","args":["fastapi._compat.v2.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_model_name_map":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["unique_models"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v2.get_model_name_map","name":"get_model_name_map","original_first_arg":"unique_models","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["unique_models"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi._compat.v2.TypeModelSet"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_model_name_map","ret_type":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi._compat.v2.TypeModelOrEnum"},"builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_origin":{".class":"SymbolTableNode","cross_ref":"typing_extensions.get_origin","kind":"Gdef"},"get_schema_from_model_field":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3,3,5],"arg_names":["field","model_name_map","field_mapping","separate_input_output_schemas"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v2.get_schema_from_model_field","name":"get_schema_from_model_field","original_first_arg":"field","type":{".class":"CallableType","arg_kinds":[3,3,3,5],"arg_names":["field","model_name_map","field_mapping","separate_input_output_schemas"],"arg_types":["fastapi._compat.v2.ModelField",{".class":"TypeAliasType","args":[],"type_ref":"fastapi.types.ModelNameMap"},{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["fastapi._compat.v2.ModelField",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"validation"},{".class":"LiteralType","fallback":"builtins.str","value":"serialization"}],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.json_schema.JsonSchemaValue"}],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_schema_from_model_field","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_bytes_field":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["field"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v2.is_bytes_field","name":"is_bytes_field","original_first_arg":"field","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["field"],"arg_types":["fastapi._compat.v2.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_bytes_field","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_bytes_sequence_field":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["field"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v2.is_bytes_sequence_field","name":"is_bytes_sequence_field","original_first_arg":"field","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["field"],"arg_types":["fastapi._compat.v2.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_bytes_sequence_field","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_scalar_field":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["field"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v2.is_scalar_field","name":"is_scalar_field","original_first_arg":"field","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["field"],"arg_types":["fastapi._compat.v2.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_scalar_field","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_scalar_sequence_field":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["field"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v2.is_scalar_sequence_field","name":"is_scalar_sequence_field","original_first_arg":"field","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["field"],"arg_types":["fastapi._compat.v2.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_scalar_sequence_field","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_sequence_field":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["field"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v2.is_sequence_field","name":"is_sequence_field","original_first_arg":"field","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["field"],"arg_types":["fastapi._compat.v2.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_sequence_field","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"lenient_issubclass":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._utils.lenient_issubclass","kind":"Gdef"},"may_v1":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.may_v1","kind":"Gdef"},"normalize_name":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v2.normalize_name","name":"normalize_name","original_first_arg":"name","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["name"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"normalize_name","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef"},"serialize_sequence_value":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3],"arg_names":["field","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi._compat.v2.serialize_sequence_value","name":"serialize_sequence_value","original_first_arg":"field","type":{".class":"CallableType","arg_kinds":[3,3],"arg_names":["field","value"],"arg_types":["fastapi._compat.v2.ModelField",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"serialize_sequence_value","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Sequence"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"shared":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.shared","kind":"Gdef"},"warnings":{".class":"SymbolTableNode","cross_ref":"warnings","kind":"Gdef"},"with_info_plain_validator_function":{".class":"SymbolTableNode","cross_ref":"pydantic_core.core_schema.with_info_plain_validator_function","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/_compat/v2.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/v2.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/v2.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..d5e50fd8d73ae6ace48b341401a9be007f902250 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/_compat/v2.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[18,18,19,25,28,29,18,20,30,31,43,92,1,2,3,4,5,6,21,33,36,1,1,1,1,1,1,1,1,1,1,1,1,1],"dep_prios":[10,10,5,5,5,5,20,5,5,5,5,20,10,10,5,5,5,5,5,5,5,5,30,30,30,30,30,30,30,30,30,30,30,30],"dependencies":["fastapi._compat.may_v1","fastapi._compat.shared","fastapi.openapi.constants","pydantic._internal._schema_generation_shared","pydantic._internal._typing_extra","pydantic._internal._utils","fastapi._compat","fastapi.types","pydantic.fields","pydantic.json_schema","pydantic_core.core_schema","pydantic.warnings","re","warnings","copy","dataclasses","enum","typing","pydantic","pydantic_core","typing_extensions","builtins","_frozen_importlib","abc","pydantic._internal","pydantic._internal._generate_schema","pydantic._internal._model_construction","pydantic._internal._repr","pydantic.aliases","pydantic.config","pydantic.main","pydantic.type_adapter","pydantic_core._pydantic_core","types"],"hash":"1edaac741990b1512c75a43afed97a62f4c8232f","id":"fastapi._compat.v2","ignore_all":true,"interface_hash":"5a8803ef4b2e674355d7f237f87f5ce6a918dfee","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/_compat/v2.py","plugin_data":null,"size":16597,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/dependencies/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/dependencies/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..1c1b34ec99dbd3ed4fa1f30b4d2c1f8f527a7079 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/dependencies/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"fastapi.dependencies","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.dependencies.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.dependencies.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.dependencies.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.dependencies.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.dependencies.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.dependencies.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.dependencies.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/dependencies/__init__.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/dependencies/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/dependencies/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..1128f0bddc979f01b990c2f5328d7dae8ec00b96 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/dependencies/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106713,"dep_lines":[1,1,1,1],"dep_prios":[5,30,30,30],"dependencies":["builtins","_frozen_importlib","abc","typing"],"hash":"da39a3ee5e6b4b0d3255bfef95601890afd80709","id":"fastapi.dependencies","ignore_all":true,"interface_hash":"6e401bec1537b7226e2ed3885671f0ca9d3110fe","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/dependencies/__init__.py","plugin_data":null,"size":0,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/dependencies/models.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/dependencies/models.data.json new file mode 100644 index 0000000000000000000000000000000000000000..e501a8fe9726a784543ecf285cba475272f465cc --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/dependencies/models.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"fastapi.dependencies.models","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"Dependant":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.dependencies.models.Dependant","name":"Dependant","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.dependencies.models.Dependant","has_param_spec_type":false,"metaclass_type":null,"metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":26,"name":"path_params","type":{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":27,"name":"query_params","type":{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":28,"name":"header_params","type":{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":29,"name":"cookie_params","type":{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":30,"name":"body_params","type":{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":31,"name":"dependencies","type":{".class":"Instance","args":["fastapi.dependencies.models.Dependant"],"extra_attrs":null,"type_ref":"builtins.list"}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":32,"name":"security_requirements","type":{".class":"Instance","args":["fastapi.dependencies.models.SecurityRequirement"],"extra_attrs":null,"type_ref":"builtins.list"}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":33,"name":"name","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":34,"name":"call","type":{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":35,"name":"request_param_name","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":36,"name":"websocket_param_name","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":37,"name":"http_connection_param_name","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":38,"name":"response_param_name","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":39,"name":"background_tasks_param_name","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":40,"name":"security_scopes_param_name","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":41,"name":"security_scopes","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":42,"name":"use_cache","type":"builtins.bool"},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":43,"name":"path","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":44,"name":"scope","type":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"function"},{".class":"LiteralType","fallback":"builtins.str","value":"request"},{".class":"NoneType"}],"uses_pep604_syntax":false}}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.dependencies.models","mro":["fastapi.dependencies.models.Dependant","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.dependencies.models.Dependant.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"dataclasses.Field"}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],"arg_names":["self","path_params","query_params","header_params","cookie_params","body_params","dependencies","security_requirements","name","call","request_param_name","websocket_param_name","http_connection_param_name","response_param_name","background_tasks_param_name","security_scopes_param_name","security_scopes","use_cache","path","scope"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.dependencies.models.Dependant.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],"arg_names":["self","path_params","query_params","header_params","cookie_params","body_params","dependencies","security_requirements","name","call","request_param_name","websocket_param_name","http_connection_param_name","response_param_name","background_tasks_param_name","security_scopes_param_name","security_scopes","use_cache","path","scope"],"arg_types":["fastapi.dependencies.models.Dependant",{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":["fastapi.dependencies.models.Dependant"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":["fastapi.dependencies.models.SecurityRequirement"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"function"},{".class":"LiteralType","fallback":"builtins.str","value":"request"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of Dependant","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["path_params","query_params","header_params","cookie_params","body_params","dependencies","security_requirements","name","call","request_param_name","websocket_param_name","http_connection_param_name","response_param_name","background_tasks_param_name","security_scopes_param_name","security_scopes","use_cache","path","scope"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.dependencies.models.Dependant.__mypy-replace","name":"__mypy-replace","original_first_arg":"path_params","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["path_params","query_params","header_params","cookie_params","body_params","dependencies","security_requirements","name","call","request_param_name","websocket_param_name","http_connection_param_name","response_param_name","background_tasks_param_name","security_scopes_param_name","security_scopes","use_cache","path","scope"],"arg_types":[{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":["fastapi.dependencies.models.Dependant"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":["fastapi.dependencies.models.SecurityRequirement"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"function"},{".class":"LiteralType","fallback":"builtins.str","value":"request"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of Dependant","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.dependencies.models.Dependant.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["path_params","query_params","header_params","cookie_params","body_params","dependencies","security_requirements","name","call","request_param_name","websocket_param_name","http_connection_param_name","response_param_name","background_tasks_param_name","security_scopes_param_name","security_scopes","use_cache","path","scope"],"arg_types":[{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":["fastapi.dependencies.models.Dependant"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":["fastapi.dependencies.models.SecurityRequirement"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"function"},{".class":"LiteralType","fallback":"builtins.str","value":"request"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of Dependant","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"background_tasks_param_name":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.dependencies.models.Dependant.background_tasks_param_name","name":"background_tasks_param_name","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"body_params":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.dependencies.models.Dependant.body_params","name":"body_params","setter_type":null,"type":{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"}}},"cache_key":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"fastapi.dependencies.models.Dependant.cache_key","name":"cache_key","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi.dependencies.models.Dependant"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cache_key of Dependant","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"fastapi.types.DependencyCacheKey"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_settable_property","is_ready","is_inferred"],"fullname":"fastapi.dependencies.models.Dependant.cache_key","name":"cache_key","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi.dependencies.models.Dependant"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cache_key of Dependant","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"fastapi.types.DependencyCacheKey"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"call":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.dependencies.models.Dependant.call","name":"call","setter_type":null,"type":{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"computed_scope":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"fastapi.dependencies.models.Dependant.computed_scope","name":"computed_scope","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi.dependencies.models.Dependant"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"computed_scope of Dependant","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_settable_property","is_ready","is_inferred"],"fullname":"fastapi.dependencies.models.Dependant.computed_scope","name":"computed_scope","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi.dependencies.models.Dependant"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"computed_scope of Dependant","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"cookie_params":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.dependencies.models.Dependant.cookie_params","name":"cookie_params","setter_type":null,"type":{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"}}},"dependencies":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.dependencies.models.Dependant.dependencies","name":"dependencies","setter_type":null,"type":{".class":"Instance","args":["fastapi.dependencies.models.Dependant"],"extra_attrs":null,"type_ref":"builtins.list"}}},"header_params":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.dependencies.models.Dependant.header_params","name":"header_params","setter_type":null,"type":{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"}}},"http_connection_param_name":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.dependencies.models.Dependant.http_connection_param_name","name":"http_connection_param_name","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"is_async_gen_callable":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"fastapi.dependencies.models.Dependant.is_async_gen_callable","name":"is_async_gen_callable","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi.dependencies.models.Dependant"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_async_gen_callable of Dependant","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_settable_property","is_ready","is_inferred"],"fullname":"fastapi.dependencies.models.Dependant.is_async_gen_callable","name":"is_async_gen_callable","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi.dependencies.models.Dependant"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_async_gen_callable of Dependant","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"is_coroutine_callable":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"fastapi.dependencies.models.Dependant.is_coroutine_callable","name":"is_coroutine_callable","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi.dependencies.models.Dependant"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_coroutine_callable of Dependant","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_settable_property","is_ready","is_inferred"],"fullname":"fastapi.dependencies.models.Dependant.is_coroutine_callable","name":"is_coroutine_callable","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi.dependencies.models.Dependant"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_coroutine_callable of Dependant","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"is_gen_callable":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"fastapi.dependencies.models.Dependant.is_gen_callable","name":"is_gen_callable","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi.dependencies.models.Dependant"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_gen_callable of Dependant","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_settable_property","is_ready","is_inferred"],"fullname":"fastapi.dependencies.models.Dependant.is_gen_callable","name":"is_gen_callable","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi.dependencies.models.Dependant"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_gen_callable of Dependant","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"name":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.dependencies.models.Dependant.name","name":"name","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"path":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.dependencies.models.Dependant.path","name":"path","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"path_params":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.dependencies.models.Dependant.path_params","name":"path_params","setter_type":null,"type":{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"}}},"query_params":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.dependencies.models.Dependant.query_params","name":"query_params","setter_type":null,"type":{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"}}},"request_param_name":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.dependencies.models.Dependant.request_param_name","name":"request_param_name","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"response_param_name":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.dependencies.models.Dependant.response_param_name","name":"response_param_name","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"scope":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.dependencies.models.Dependant.scope","name":"scope","setter_type":null,"type":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"function"},{".class":"LiteralType","fallback":"builtins.str","value":"request"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"security_requirements":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.dependencies.models.Dependant.security_requirements","name":"security_requirements","setter_type":null,"type":{".class":"Instance","args":["fastapi.dependencies.models.SecurityRequirement"],"extra_attrs":null,"type_ref":"builtins.list"}}},"security_scopes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.dependencies.models.Dependant.security_scopes","name":"security_scopes","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"security_scopes_param_name":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.dependencies.models.Dependant.security_scopes_param_name","name":"security_scopes_param_name","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"use_cache":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.dependencies.models.Dependant.use_cache","name":"use_cache","setter_type":null,"type":"builtins.bool"}},"websocket_param_name":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.dependencies.models.Dependant.websocket_param_name","name":"websocket_param_name","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.dependencies.models.Dependant.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.dependencies.models.Dependant","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"DependencyCacheKey":{".class":"SymbolTableNode","cross_ref":"fastapi.types.DependencyCacheKey","kind":"Gdef"},"List":{".class":"SymbolTableNode","cross_ref":"typing.List","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Literal","kind":"Gdef"},"ModelField":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.model_field.ModelField","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"SecurityBase":{".class":"SymbolTableNode","cross_ref":"fastapi.security.base.SecurityBase","kind":"Gdef"},"SecurityRequirement":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.dependencies.models.SecurityRequirement","name":"SecurityRequirement","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.dependencies.models.SecurityRequirement","has_param_spec_type":false,"metaclass_type":null,"metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":20,"name":"security_scheme","type":"fastapi.security.base.SecurityBase"},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":21,"name":"scopes","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":false}}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.dependencies.models","mro":["fastapi.dependencies.models.SecurityRequirement","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.dependencies.models.SecurityRequirement.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"dataclasses.Field"}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","security_scheme","scopes"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.dependencies.models.SecurityRequirement.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","security_scheme","scopes"],"arg_types":["fastapi.dependencies.models.SecurityRequirement","fastapi.security.base.SecurityBase",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of SecurityRequirement","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5],"arg_names":["security_scheme","scopes"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.dependencies.models.SecurityRequirement.__mypy-replace","name":"__mypy-replace","original_first_arg":"security_scheme","type":{".class":"CallableType","arg_kinds":[5,5],"arg_names":["security_scheme","scopes"],"arg_types":["fastapi.security.base.SecurityBase",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of SecurityRequirement","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.dependencies.models.SecurityRequirement.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5],"arg_names":["security_scheme","scopes"],"arg_types":["fastapi.security.base.SecurityBase",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of SecurityRequirement","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"scopes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.dependencies.models.SecurityRequirement.scopes","name":"scopes","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"security_scheme":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.dependencies.models.SecurityRequirement.security_scheme","name":"security_scheme","setter_type":null,"type":"fastapi.security.base.SecurityBase"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.dependencies.models.SecurityRequirement.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.dependencies.models.SecurityRequirement","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.dependencies.models.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.dependencies.models.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.dependencies.models.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.dependencies.models.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.dependencies.models.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.dependencies.models.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"cached_property":{".class":"SymbolTableNode","cross_ref":"functools.cached_property","kind":"Gdef"},"dataclass":{".class":"SymbolTableNode","cross_ref":"dataclasses.dataclass","kind":"Gdef"},"field":{".class":"SymbolTableNode","cross_ref":"dataclasses.field","kind":"Gdef"},"inspect":{".class":"SymbolTableNode","cross_ref":"inspect","kind":"Gdef"},"iscoroutinefunction":{".class":"SymbolTableNode","cross_ref":"asyncio.coroutines.iscoroutinefunction","kind":"Gdef"},"sys":{".class":"SymbolTableNode","cross_ref":"sys","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/dependencies/models.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/dependencies/models.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/dependencies/models.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..b1e02eefdd782ff89610a7536bae667650d88aa0 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/dependencies/models.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106718,"dep_lines":[8,7,9,1,2,3,4,5,10,15,1,1,1,1,1,1,1],"dep_prios":[5,5,5,10,10,5,5,5,5,5,5,30,30,30,30,30,30],"dependencies":["fastapi.security.base","fastapi._compat","fastapi.types","inspect","sys","dataclasses","functools","typing","typing_extensions","asyncio","builtins","_frozen_importlib","_typeshed","abc","enum","fastapi._compat.model_field","fastapi.security"],"hash":"cc4a6304aa5fbdd304fd187291525f7d424341e6","id":"fastapi.dependencies.models","ignore_all":true,"interface_hash":"de95fb554bb33a1789f14a3bd2dcab122a26200e","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/dependencies/models.py","plugin_data":null,"size":3004,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/dependencies/utils.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/dependencies/utils.data.json new file mode 100644 index 0000000000000000000000000000000000000000..fa6eef7b48295e5ffe7ed5280e4f37af78eae04b --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/dependencies/utils.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"fastapi.dependencies.utils","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Annotated":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Annotated","kind":"Gdef"},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"AsyncExitStack":{".class":"SymbolTableNode","cross_ref":"contextlib.AsyncExitStack","kind":"Gdef"},"BackgroundTasks":{".class":"SymbolTableNode","cross_ref":"fastapi.background.BackgroundTasks","kind":"Gdef"},"BaseModel":{".class":"SymbolTableNode","cross_ref":"pydantic.main.BaseModel","kind":"Gdef"},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"Coroutine":{".class":"SymbolTableNode","cross_ref":"typing.Coroutine","kind":"Gdef"},"Dependant":{".class":"SymbolTableNode","cross_ref":"fastapi.dependencies.models.Dependant","kind":"Gdef"},"DependencyCacheKey":{".class":"SymbolTableNode","cross_ref":"fastapi.types.DependencyCacheKey","kind":"Gdef"},"DependencyScopeError":{".class":"SymbolTableNode","cross_ref":"fastapi.exceptions.DependencyScopeError","kind":"Gdef"},"Dict":{".class":"SymbolTableNode","cross_ref":"typing.Dict","kind":"Gdef"},"FieldInfo":{".class":"SymbolTableNode","cross_ref":"pydantic.fields.FieldInfo","kind":"Gdef"},"FormData":{".class":"SymbolTableNode","cross_ref":"starlette.datastructures.FormData","kind":"Gdef"},"ForwardRef":{".class":"SymbolTableNode","cross_ref":"typing.ForwardRef","kind":"Gdef"},"HTTPConnection":{".class":"SymbolTableNode","cross_ref":"starlette.requests.HTTPConnection","kind":"Gdef"},"Headers":{".class":"SymbolTableNode","cross_ref":"starlette.datastructures.Headers","kind":"Gdef"},"ImmutableMultiDict":{".class":"SymbolTableNode","cross_ref":"starlette.datastructures.ImmutableMultiDict","kind":"Gdef"},"List":{".class":"SymbolTableNode","cross_ref":"typing.List","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Literal","kind":"Gdef"},"Mapping":{".class":"SymbolTableNode","cross_ref":"typing.Mapping","kind":"Gdef"},"ModelField":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.model_field.ModelField","kind":"Gdef"},"OAuth2":{".class":"SymbolTableNode","cross_ref":"fastapi.security.oauth2.OAuth2","kind":"Gdef"},"OpenIdConnect":{".class":"SymbolTableNode","cross_ref":"fastapi.security.open_id_connect_url.OpenIdConnect","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"PYDANTIC_V2":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.shared.PYDANTIC_V2","kind":"Gdef"},"ParamDetails":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.dependencies.utils.ParamDetails","name":"ParamDetails","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.dependencies.utils.ParamDetails","has_param_spec_type":false,"metaclass_type":null,"metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":337,"name":"type_annotation","type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":338,"name":"depends","type":{".class":"UnionType","items":["fastapi.params.Depends",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":339,"name":"field","type":{".class":"UnionType","items":["fastapi._compat.model_field.ModelField",{".class":"NoneType"}],"uses_pep604_syntax":false}}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.dependencies.utils","mro":["fastapi.dependencies.utils.ParamDetails","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.dependencies.utils.ParamDetails.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"dataclasses.Field"}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","type_annotation","depends","field"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.dependencies.utils.ParamDetails.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","type_annotation","depends","field"],"arg_types":["fastapi.dependencies.utils.ParamDetails",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["fastapi.params.Depends",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi._compat.model_field.ModelField",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of ParamDetails","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5],"arg_names":["type_annotation","depends","field"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.dependencies.utils.ParamDetails.__mypy-replace","name":"__mypy-replace","original_first_arg":"type_annotation","type":{".class":"CallableType","arg_kinds":[5,5,5],"arg_names":["type_annotation","depends","field"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["fastapi.params.Depends",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi._compat.model_field.ModelField",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of ParamDetails","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.dependencies.utils.ParamDetails.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5],"arg_names":["type_annotation","depends","field"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["fastapi.params.Depends",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi._compat.model_field.ModelField",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of ParamDetails","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"depends":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.dependencies.utils.ParamDetails.depends","name":"depends","setter_type":null,"type":{".class":"UnionType","items":["fastapi.params.Depends",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"field":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.dependencies.utils.ParamDetails.field","name":"field","setter_type":null,"type":{".class":"UnionType","items":["fastapi._compat.model_field.ModelField",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"type_annotation":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.dependencies.utils.ParamDetails.type_annotation","name":"type_annotation","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.dependencies.utils.ParamDetails.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.dependencies.utils.ParamDetails","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"QueryParams":{".class":"SymbolTableNode","cross_ref":"starlette.datastructures.QueryParams","kind":"Gdef"},"Request":{".class":"SymbolTableNode","cross_ref":"starlette.requests.Request","kind":"Gdef"},"RequiredParam":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.v2.RequiredParam","kind":"Gdef"},"Response":{".class":"SymbolTableNode","cross_ref":"starlette.responses.Response","kind":"Gdef"},"SecurityBase":{".class":"SymbolTableNode","cross_ref":"fastapi.security.base.SecurityBase","kind":"Gdef"},"SecurityRequirement":{".class":"SymbolTableNode","cross_ref":"fastapi.dependencies.models.SecurityRequirement","kind":"Gdef"},"SecurityScopes":{".class":"SymbolTableNode","cross_ref":"fastapi.security.oauth2.SecurityScopes","kind":"Gdef"},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef"},"SolvedDependency":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.dependencies.utils.SolvedDependency","name":"SolvedDependency","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.dependencies.utils.SolvedDependency","has_param_spec_type":false,"metaclass_type":null,"metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":558,"name":"values","type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":559,"name":"errors","type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":560,"name":"background_tasks","type":{".class":"UnionType","items":["starlette.background.BackgroundTasks",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":561,"name":"response","type":"starlette.responses.Response"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":562,"name":"dependency_cache","type":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.types.DependencyCacheKey"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.dependencies.utils","mro":["fastapi.dependencies.utils.SolvedDependency","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.dependencies.utils.SolvedDependency.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"dataclasses.Field"}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0,0],"arg_names":["self","values","errors","background_tasks","response","dependency_cache"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.dependencies.utils.SolvedDependency.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0],"arg_names":["self","values","errors","background_tasks","response","dependency_cache"],"arg_types":["fastapi.dependencies.utils.SolvedDependency",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"UnionType","items":["starlette.background.BackgroundTasks",{".class":"NoneType"}],"uses_pep604_syntax":false},"starlette.responses.Response",{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.types.DependencyCacheKey"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of SolvedDependency","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5],"arg_names":["values","errors","background_tasks","response","dependency_cache"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.dependencies.utils.SolvedDependency.__mypy-replace","name":"__mypy-replace","original_first_arg":"values","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5],"arg_names":["values","errors","background_tasks","response","dependency_cache"],"arg_types":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"UnionType","items":["starlette.background.BackgroundTasks",{".class":"NoneType"}],"uses_pep604_syntax":false},"starlette.responses.Response",{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.types.DependencyCacheKey"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of SolvedDependency","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.dependencies.utils.SolvedDependency.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5],"arg_names":["values","errors","background_tasks","response","dependency_cache"],"arg_types":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"UnionType","items":["starlette.background.BackgroundTasks",{".class":"NoneType"}],"uses_pep604_syntax":false},"starlette.responses.Response",{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.types.DependencyCacheKey"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of SolvedDependency","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"background_tasks":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.dependencies.utils.SolvedDependency.background_tasks","name":"background_tasks","setter_type":null,"type":{".class":"UnionType","items":["starlette.background.BackgroundTasks",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"dependency_cache":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.dependencies.utils.SolvedDependency.dependency_cache","name":"dependency_cache","setter_type":null,"type":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.types.DependencyCacheKey"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"errors":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.dependencies.utils.SolvedDependency.errors","name":"errors","setter_type":null,"type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"}}},"response":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.dependencies.utils.SolvedDependency.response","name":"response","setter_type":null,"type":"starlette.responses.Response"}},"values":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.dependencies.utils.SolvedDependency.values","name":"values","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.dependencies.utils.SolvedDependency.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.dependencies.utils.SolvedDependency","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"StarletteBackgroundTasks":{".class":"SymbolTableNode","cross_ref":"starlette.background.BackgroundTasks","kind":"Gdef"},"Tuple":{".class":"SymbolTableNode","cross_ref":"typing.Tuple","kind":"Gdef"},"Type":{".class":"SymbolTableNode","cross_ref":"typing.Type","kind":"Gdef"},"Undefined":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.v2.Undefined","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"UploadFile":{".class":"SymbolTableNode","cross_ref":"starlette.datastructures.UploadFile","kind":"Gdef"},"WebSocket":{".class":"SymbolTableNode","cross_ref":"starlette.websockets.WebSocket","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.dependencies.utils.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.dependencies.utils.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.dependencies.utils.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.dependencies.utils.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.dependencies.utils.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.dependencies.utils.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_extract_form_body":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["body_fields","received_body"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine"],"fullname":"fastapi.dependencies.utils._extract_form_body","name":"_extract_form_body","original_first_arg":"body_fields","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["body_fields","received_body"],"arg_types":[{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"},"starlette.datastructures.FormData"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_extract_form_body","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_get_flat_fields_from_params":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["fields"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.dependencies.utils._get_flat_fields_from_params","name":"_get_flat_fields_from_params","original_first_arg":"fields","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["fields"],"arg_types":[{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_flat_fields_from_params","ret_type":{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_get_multidict_value":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["field","values","alias"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.dependencies.utils._get_multidict_value","name":"_get_multidict_value","original_first_arg":"field","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["field","values","alias"],"arg_types":["fastapi._compat.model_field.ModelField",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_multidict_value","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_is_error_wrapper":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main._is_error_wrapper","kind":"Gdef"},"_is_model_class":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main._is_model_class","kind":"Gdef"},"_should_embed_body_fields":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["fields"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.dependencies.utils._should_embed_body_fields","name":"_should_embed_body_fields","original_first_arg":"fields","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["fields"],"arg_types":[{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_should_embed_body_fields","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_solve_generator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3,3],"arg_names":["dependant","stack","sub_values"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine"],"fullname":"fastapi.dependencies.utils._solve_generator","name":"_solve_generator","original_first_arg":"dependant","type":{".class":"CallableType","arg_kinds":[3,3,3],"arg_names":["dependant","stack","sub_values"],"arg_types":["fastapi.dependencies.models.Dependant",{".class":"Instance","args":[{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"contextlib.AsyncExitStack"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_solve_generator","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_validate_value_with_model_field":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3,3,3],"arg_names":["field","value","values","loc"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.dependencies.utils._validate_value_with_model_field","name":"_validate_value_with_model_field","original_first_arg":"field","type":{".class":"CallableType","arg_kinds":[3,3,3,3],"arg_names":["field","value","values","loc"],"arg_types":["fastapi._compat.model_field.ModelField",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_validate_value_with_model_field","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"add_non_field_param_to_dependency":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3,3],"arg_names":["param_name","type_annotation","dependant"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.dependencies.utils.add_non_field_param_to_dependency","name":"add_non_field_param_to_dependency","original_first_arg":"param_name","type":{".class":"CallableType","arg_kinds":[3,3,3],"arg_names":["param_name","type_annotation","dependant"],"arg_types":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"fastapi.dependencies.models.Dependant"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add_non_field_param_to_dependency","ret_type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"add_param_to_fields":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3],"arg_names":["field","dependant"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.dependencies.utils.add_param_to_fields","name":"add_param_to_fields","original_first_arg":"field","type":{".class":"CallableType","arg_kinds":[3,3],"arg_names":["field","dependant"],"arg_types":["fastapi._compat.model_field.ModelField","fastapi.dependencies.models.Dependant"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add_param_to_fields","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"analyze_param":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3,3,3],"arg_names":["param_name","annotation","value","is_path_param"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.dependencies.utils.analyze_param","name":"analyze_param","original_first_arg":"param_name","type":{".class":"CallableType","arg_kinds":[3,3,3,3],"arg_names":["param_name","annotation","value","is_path_param"],"arg_types":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"analyze_param","ret_type":"fastapi.dependencies.utils.ParamDetails","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"annotation_is_pydantic_v1":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.shared.annotation_is_pydantic_v1","kind":"Gdef"},"anyio":{".class":"SymbolTableNode","cross_ref":"anyio","kind":"Gdef"},"asynccontextmanager":{".class":"SymbolTableNode","cross_ref":"contextlib.asynccontextmanager","kind":"Gdef"},"cast":{".class":"SymbolTableNode","cross_ref":"typing.cast","kind":"Gdef"},"contextmanager":{".class":"SymbolTableNode","cross_ref":"contextlib.contextmanager","kind":"Gdef"},"contextmanager_in_threadpool":{".class":"SymbolTableNode","cross_ref":"fastapi.concurrency.contextmanager_in_threadpool","kind":"Gdef"},"copy":{".class":"SymbolTableNode","cross_ref":"copy.copy","kind":"Gdef"},"copy_field_info":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main.copy_field_info","kind":"Gdef"},"create_body_model":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main.create_body_model","kind":"Gdef"},"create_model_field":{".class":"SymbolTableNode","cross_ref":"fastapi.utils.create_model_field","kind":"Gdef"},"dataclass":{".class":"SymbolTableNode","cross_ref":"dataclasses.dataclass","kind":"Gdef"},"dataclasses":{".class":"SymbolTableNode","cross_ref":"dataclasses","kind":"Gdef"},"deepcopy":{".class":"SymbolTableNode","cross_ref":"copy.deepcopy","kind":"Gdef"},"ensure_multipart_is_installed":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.dependencies.utils.ensure_multipart_is_installed","name":"ensure_multipart_is_installed","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ensure_multipart_is_installed","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"evaluate_forwardref":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.v2.evaluate_forwardref","kind":"Gdef"},"field_annotation_is_scalar":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.shared.field_annotation_is_scalar","kind":"Gdef"},"get_annotation_from_field_info":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main.get_annotation_from_field_info","kind":"Gdef"},"get_args":{".class":"SymbolTableNode","cross_ref":"typing_extensions.get_args","kind":"Gdef"},"get_body_field":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3,3],"arg_names":["flat_dependant","name","embed_body_fields"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.dependencies.utils.get_body_field","name":"get_body_field","original_first_arg":"flat_dependant","type":{".class":"CallableType","arg_kinds":[3,3,3],"arg_names":["flat_dependant","name","embed_body_fields"],"arg_types":["fastapi.dependencies.models.Dependant","builtins.str","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_body_field","ret_type":{".class":"UnionType","items":["fastapi._compat.model_field.ModelField",{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_cached_model_fields":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main.get_cached_model_fields","kind":"Gdef"},"get_dependant":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3,5,5,5,5],"arg_names":["path","call","name","security_scopes","use_cache","scope"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.dependencies.utils.get_dependant","name":"get_dependant","original_first_arg":"path","type":{".class":"CallableType","arg_kinds":[3,3,5,5,5,5],"arg_names":["path","call","name","security_scopes","use_cache","scope"],"arg_types":["builtins.str",{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"function"},{".class":"LiteralType","fallback":"builtins.str","value":"request"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_dependant","ret_type":"fastapi.dependencies.models.Dependant","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_flat_dependant":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5],"arg_names":["dependant","skip_repeats","visited"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.dependencies.utils.get_flat_dependant","name":"get_flat_dependant","original_first_arg":"dependant","type":{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":["dependant","skip_repeats","visited"],"arg_types":["fastapi.dependencies.models.Dependant","builtins.bool",{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.types.DependencyCacheKey"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_flat_dependant","ret_type":"fastapi.dependencies.models.Dependant","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_flat_params":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["dependant"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.dependencies.utils.get_flat_params","name":"get_flat_params","original_first_arg":"dependant","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dependant"],"arg_types":["fastapi.dependencies.models.Dependant"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_flat_params","ret_type":{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_missing_field_error":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.v2.get_missing_field_error","kind":"Gdef"},"get_origin":{".class":"SymbolTableNode","cross_ref":"typing_extensions.get_origin","kind":"Gdef"},"get_parameterless_sub_dependant":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3],"arg_names":["depends","path"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.dependencies.utils.get_parameterless_sub_dependant","name":"get_parameterless_sub_dependant","original_first_arg":"depends","type":{".class":"CallableType","arg_kinds":[3,3],"arg_names":["depends","path"],"arg_types":["fastapi.params.Depends","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_parameterless_sub_dependant","ret_type":"fastapi.dependencies.models.Dependant","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_path_param_names":{".class":"SymbolTableNode","cross_ref":"fastapi.utils.get_path_param_names","kind":"Gdef"},"get_typed_annotation":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["annotation","globalns"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.dependencies.utils.get_typed_annotation","name":"get_typed_annotation","original_first_arg":"annotation","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["annotation","globalns"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_typed_annotation","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_typed_return_annotation":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["call"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.dependencies.utils.get_typed_return_annotation","name":"get_typed_return_annotation","original_first_arg":"call","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["call"],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_typed_return_annotation","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_typed_signature":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["call"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.dependencies.utils.get_typed_signature","name":"get_typed_signature","original_first_arg":"call","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["call"],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_typed_signature","ret_type":"inspect.Signature","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"inspect":{".class":"SymbolTableNode","cross_ref":"inspect","kind":"Gdef"},"is_bytes_field":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main.is_bytes_field","kind":"Gdef"},"is_bytes_sequence_field":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main.is_bytes_sequence_field","kind":"Gdef"},"is_scalar_field":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main.is_scalar_field","kind":"Gdef"},"is_scalar_sequence_field":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main.is_scalar_sequence_field","kind":"Gdef"},"is_sequence_field":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main.is_sequence_field","kind":"Gdef"},"is_union_of_base_models":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["field_type"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.dependencies.utils.is_union_of_base_models","name":"is_union_of_base_models","original_first_arg":"field_type","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["field_type"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_union_of_base_models","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_uploadfile_or_nonable_uploadfile_annotation":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.shared.is_uploadfile_or_nonable_uploadfile_annotation","kind":"Gdef"},"is_uploadfile_sequence_annotation":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.shared.is_uploadfile_sequence_annotation","kind":"Gdef"},"lenient_issubclass":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.shared.lenient_issubclass","kind":"Gdef"},"logger":{".class":"SymbolTableNode","cross_ref":"fastapi.logger.logger","kind":"Gdef"},"may_v1":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.may_v1","kind":"Gdef"},"multipart_incorrect_install_error":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"fastapi.dependencies.utils.multipart_incorrect_install_error","name":"multipart_incorrect_install_error","setter_type":null,"type":"builtins.str"}},"multipart_not_installed_error":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"fastapi.dependencies.utils.multipart_not_installed_error","name":"multipart_not_installed_error","setter_type":null,"type":"builtins.str"}},"params":{".class":"SymbolTableNode","cross_ref":"fastapi.params","kind":"Gdef"},"request_body_to_args":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["body_fields","received_body","embed_body_fields"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine"],"fullname":"fastapi.dependencies.utils.request_body_to_args","name":"request_body_to_args","original_first_arg":"body_fields","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["body_fields","received_body","embed_body_fields"],"arg_types":[{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"starlette.datastructures.FormData",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"request_body_to_args","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"TupleType","implicit":false,"items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"extra_attrs":null,"type_ref":"builtins.list"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"request_params_to_args":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["fields","received_params"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.dependencies.utils.request_params_to_args","name":"request_params_to_args","original_first_arg":"fields","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["fields","received_params"],"arg_types":[{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Mapping"},"starlette.datastructures.QueryParams","starlette.datastructures.Headers"],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"request_params_to_args","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"run_in_threadpool":{".class":"SymbolTableNode","cross_ref":"starlette.concurrency.run_in_threadpool","kind":"Gdef"},"sequence_types":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.shared.sequence_types","kind":"Gdef"},"serialize_sequence_value":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main.serialize_sequence_value","kind":"Gdef"},"solve_dependencies":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3,5,5,5,5,5,3,3],"arg_names":["request","dependant","body","background_tasks","response","dependency_overrides_provider","dependency_cache","async_exit_stack","embed_body_fields"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine"],"fullname":"fastapi.dependencies.utils.solve_dependencies","name":"solve_dependencies","original_first_arg":"request","type":{".class":"CallableType","arg_kinds":[3,3,5,5,5,5,5,3,3],"arg_names":["request","dependant","body","background_tasks","response","dependency_overrides_provider","dependency_cache","async_exit_stack","embed_body_fields"],"arg_types":[{".class":"UnionType","items":["starlette.requests.Request","starlette.websockets.WebSocket"],"uses_pep604_syntax":false},"fastapi.dependencies.models.Dependant",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"starlette.datastructures.FormData",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["starlette.background.BackgroundTasks",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["starlette.responses.Response",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.types.DependencyCacheKey"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":[{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"contextlib.AsyncExitStack"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"solve_dependencies","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"fastapi.dependencies.utils.SolvedDependency"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"temp_pydantic_v1_params":{".class":"SymbolTableNode","cross_ref":"fastapi.temp_pydantic_v1_params","kind":"Gdef"},"value_is_sequence":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.shared.value_is_sequence","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/dependencies/utils.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/dependencies/utils.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/dependencies/utils.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..5ebdd3a37678673af485f25f18985b55a2bd8342 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/dependencies/utils.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106718,"dep_lines":[24,51,57,60,61,62,23,24,52,53,58,59,63,64,66,67,68,69,76,77,78,81,1,2,3,4,6,22,23,65,79,1,1,1,1,1],"dep_prios":[10,5,5,5,5,5,10,5,5,5,5,5,5,5,5,5,5,5,5,5,5,10,5,10,5,5,5,10,20,5,5,5,30,30,30,30],"dependencies":["fastapi._compat.may_v1","fastapi._compat.shared","fastapi.dependencies.models","fastapi.security.base","fastapi.security.oauth2","fastapi.security.open_id_connect_url","fastapi.params","fastapi._compat","fastapi.background","fastapi.concurrency","fastapi.exceptions","fastapi.logger","fastapi.types","fastapi.utils","pydantic.fields","starlette.background","starlette.concurrency","starlette.datastructures","starlette.requests","starlette.responses","starlette.websockets","fastapi.temp_pydantic_v1_params","dataclasses","inspect","contextlib","copy","typing","anyio","fastapi","pydantic","typing_extensions","builtins","_frozen_importlib","abc","fastapi._compat.model_field","starlette"],"hash":"0fff83cdea33bf2c6acefec4c86a63af5bfb495a","id":"fastapi.dependencies.utils","ignore_all":true,"interface_hash":"6c1639696a1ac3e05b21332135f2a8ba2fa0bd97","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/dependencies/utils.py","plugin_data":null,"size":38641,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/middleware/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/middleware/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..687ee4db2df6c24464701ce99e1c7f95022840e2 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/middleware/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"fastapi.middleware","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Middleware":{".class":"SymbolTableNode","cross_ref":"starlette.middleware.Middleware","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.middleware.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.middleware.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.middleware.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.middleware.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.middleware.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.middleware.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.middleware.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/middleware/__init__.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/middleware/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/middleware/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..401b8afd3d746ed2827f42364c598032e739e7d9 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/middleware/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106714,"dep_lines":[1,1,1,1,1],"dep_prios":[5,5,30,30,30],"dependencies":["starlette.middleware","builtins","_frozen_importlib","abc","typing"],"hash":"c80ef84413f18ce9d905b9064163c1d2c13a1337","id":"fastapi.middleware","ignore_all":true,"interface_hash":"5112136e3b0f2c5a633a53a9b639cd1e49727edd","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/middleware/__init__.py","plugin_data":null,"size":58,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/middleware/asyncexitstack.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/middleware/asyncexitstack.data.json new file mode 100644 index 0000000000000000000000000000000000000000..8a8e6afccfd36dc8502c747f6ad1fe9baa00f457 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/middleware/asyncexitstack.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"fastapi.middleware.asyncexitstack","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","ASGIApp":{".class":"SymbolTableNode","cross_ref":"starlette.types.ASGIApp","kind":"Gdef"},"AsyncExitStack":{".class":"SymbolTableNode","cross_ref":"contextlib.AsyncExitStack","kind":"Gdef"},"AsyncExitStackMiddleware":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.middleware.asyncexitstack.AsyncExitStackMiddleware","name":"AsyncExitStackMiddleware","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.middleware.asyncexitstack.AsyncExitStackMiddleware","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"fastapi.middleware.asyncexitstack","mro":["fastapi.middleware.asyncexitstack.AsyncExitStackMiddleware","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","scope","receive","send"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"fastapi.middleware.asyncexitstack.AsyncExitStackMiddleware.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","scope","receive","send"],"arg_types":["fastapi.middleware.asyncexitstack.AsyncExitStackMiddleware",{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Scope"},{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Receive"},{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Send"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of AsyncExitStackMiddleware","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","app","context_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"fastapi.middleware.asyncexitstack.AsyncExitStackMiddleware.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","app","context_name"],"arg_types":["fastapi.middleware.asyncexitstack.AsyncExitStackMiddleware",{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.ASGIApp"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of AsyncExitStackMiddleware","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"app":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"fastapi.middleware.asyncexitstack.AsyncExitStackMiddleware.app","name":"app","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,null,null],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Scope"},{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Receive"},{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Send"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":[{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Awaitable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"context_name":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"fastapi.middleware.asyncexitstack.AsyncExitStackMiddleware.context_name","name":"context_name","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.middleware.asyncexitstack.AsyncExitStackMiddleware.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.middleware.asyncexitstack.AsyncExitStackMiddleware","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Receive":{".class":"SymbolTableNode","cross_ref":"starlette.types.Receive","kind":"Gdef"},"Scope":{".class":"SymbolTableNode","cross_ref":"starlette.types.Scope","kind":"Gdef"},"Send":{".class":"SymbolTableNode","cross_ref":"starlette.types.Send","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.middleware.asyncexitstack.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.middleware.asyncexitstack.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.middleware.asyncexitstack.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.middleware.asyncexitstack.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.middleware.asyncexitstack.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.middleware.asyncexitstack.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/middleware/asyncexitstack.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/middleware/asyncexitstack.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/middleware/asyncexitstack.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..8890b6f1207cfe19fc8e2eda4f2abb05d2b066ad --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/middleware/asyncexitstack.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[3,1,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["starlette.types","contextlib","builtins","_frozen_importlib","abc","typing"],"hash":"70035c81cf48f1d5f5623a79db271e90b9b483c9","id":"fastapi.middleware.asyncexitstack","ignore_all":true,"interface_hash":"085739fff3825bdfa8817766cba9b047c60f26aa","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/middleware/asyncexitstack.py","plugin_data":null,"size":637,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/openapi/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/openapi/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..115f928351a25023b5998ce17ce891cbdfd888c9 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/openapi/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"fastapi.openapi","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.openapi.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.openapi.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.openapi.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.openapi.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.openapi.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.openapi.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.openapi.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/openapi/__init__.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/openapi/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/openapi/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..3e2273b1fa719b5cce04b45c0e709dfb5186ecdc --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/openapi/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106713,"dep_lines":[1,1,1,1],"dep_prios":[5,30,30,30],"dependencies":["builtins","_frozen_importlib","abc","typing"],"hash":"da39a3ee5e6b4b0d3255bfef95601890afd80709","id":"fastapi.openapi","ignore_all":true,"interface_hash":"493cb55b6493ba75c34ede241b73d48dd279a5d4","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/openapi/__init__.py","plugin_data":null,"size":0,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/openapi/constants.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/openapi/constants.data.json new file mode 100644 index 0000000000000000000000000000000000000000..d34157aa985315ac8b27d2babd6caef5583e1dca --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/openapi/constants.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"fastapi.openapi.constants","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","METHODS_WITH_BODY":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"fastapi.openapi.constants.METHODS_WITH_BODY","name":"METHODS_WITH_BODY","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"REF_PREFIX":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"fastapi.openapi.constants.REF_PREFIX","name":"REF_PREFIX","setter_type":null,"type":"builtins.str"}},"REF_TEMPLATE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"fastapi.openapi.constants.REF_TEMPLATE","name":"REF_TEMPLATE","setter_type":null,"type":"builtins.str"}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.openapi.constants.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.openapi.constants.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.openapi.constants.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.openapi.constants.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.openapi.constants.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.openapi.constants.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/openapi/constants.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/openapi/constants.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/openapi/constants.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..fce9fb41c688f9181c0fe3563d73231c9bbae5d0 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/openapi/constants.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106713,"dep_lines":[1,1,1,1],"dep_prios":[5,30,30,30],"dependencies":["builtins","_frozen_importlib","abc","typing"],"hash":"b08559cdf6081c953a6127a333979076494d6559","id":"fastapi.openapi.constants","ignore_all":true,"interface_hash":"78d4400cb3cbd2a3bc0a8d348f8de1f526be086a","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/openapi/constants.py","plugin_data":null,"size":153,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/openapi/docs.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/openapi/docs.data.json new file mode 100644 index 0000000000000000000000000000000000000000..ac81eb49afff9c0974d1dc1d326e5e66251c6cc4 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/openapi/docs.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"fastapi.openapi.docs","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Annotated":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Annotated","kind":"Gdef"},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"Dict":{".class":"SymbolTableNode","cross_ref":"typing.Dict","kind":"Gdef"},"Doc":{".class":"SymbolTableNode","cross_ref":"annotated_doc.main.Doc","kind":"Gdef"},"HTMLResponse":{".class":"SymbolTableNode","cross_ref":"starlette.responses.HTMLResponse","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.openapi.docs.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.openapi.docs.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.openapi.docs.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.openapi.docs.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.openapi.docs.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.openapi.docs.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"get_redoc_html":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3,5,5,5],"arg_names":["openapi_url","title","redoc_js_url","redoc_favicon_url","with_google_fonts"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.docs.get_redoc_html","name":"get_redoc_html","original_first_arg":"openapi_url","type":{".class":"CallableType","arg_kinds":[3,3,5,5,5],"arg_names":["openapi_url","title","redoc_js_url","redoc_favicon_url","with_google_fonts"],"arg_types":["builtins.str","builtins.str","builtins.str","builtins.str","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_redoc_html","ret_type":"starlette.responses.HTMLResponse","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_swagger_ui_html":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3,5,5,5,5,5,5],"arg_names":["openapi_url","title","swagger_js_url","swagger_css_url","swagger_favicon_url","oauth2_redirect_url","init_oauth","swagger_ui_parameters"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.docs.get_swagger_ui_html","name":"get_swagger_ui_html","original_first_arg":"openapi_url","type":{".class":"CallableType","arg_kinds":[3,3,5,5,5,5,5,5],"arg_names":["openapi_url","title","swagger_js_url","swagger_css_url","swagger_favicon_url","oauth2_redirect_url","init_oauth","swagger_ui_parameters"],"arg_types":["builtins.str","builtins.str","builtins.str","builtins.str","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_swagger_ui_html","ret_type":"starlette.responses.HTMLResponse","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_swagger_ui_oauth2_redirect_html":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.docs.get_swagger_ui_oauth2_redirect_html","name":"get_swagger_ui_oauth2_redirect_html","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_swagger_ui_oauth2_redirect_html","ret_type":"starlette.responses.HTMLResponse","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"json":{".class":"SymbolTableNode","cross_ref":"json","kind":"Gdef"},"jsonable_encoder":{".class":"SymbolTableNode","cross_ref":"fastapi.encoders.jsonable_encoder","kind":"Gdef"},"swagger_ui_default_parameters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"fastapi.openapi.docs.swagger_ui_default_parameters","name":"swagger_ui_default_parameters","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/openapi/docs.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/openapi/docs.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/openapi/docs.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..22a4fba42e9b546f4e9bdca87ae23ea32b5079bb --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/openapi/docs.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[5,6,1,2,4,7,1,1,1,1],"dep_prios":[5,5,10,5,5,5,5,30,30,30],"dependencies":["fastapi.encoders","starlette.responses","json","typing","annotated_doc","typing_extensions","builtins","_frozen_importlib","abc","starlette"],"hash":"539f1f50b1a2b55d7cb56842fe264594b4a600c3","id":"fastapi.openapi.docs","ignore_all":true,"interface_hash":"fd14021b0ad2dd1017086d696e5fc7e81107c9c4","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/openapi/docs.py","plugin_data":null,"size":10370,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/openapi/models.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/openapi/models.data.json new file mode 100644 index 0000000000000000000000000000000000000000..5b4eff43a9342edf5d268a4fa6fd4e1541d1e4ca --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/openapi/models.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"fastapi.openapi.models","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","APIKey":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.openapi.models.SecurityBase"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.APIKey","name":"APIKey","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.APIKey","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":"type","column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":356,"name":"type_","type":"fastapi.openapi.models.SecuritySchemeType"},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":346,"name":"description","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":"in","column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":357,"name":"in_","type":"fastapi.openapi.models.APIKeyIn"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":358,"name":"name","type":"builtins.str"}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.APIKey","fastapi.openapi.models.SecurityBase","fastapi.openapi.models.BaseModelWithConfig","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.openapi.models.APIKey.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,3,3],"arg_names":["self","type","description","in","name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.APIKey.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,5,3,3],"arg_names":["self","type","description","in","name"],"arg_types":["fastapi.openapi.models.APIKey","fastapi.openapi.models.SecuritySchemeType",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"fastapi.openapi.models.APIKeyIn","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of APIKey","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","type","description","in","name"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.openapi.models.APIKey.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","type","description","in","name"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"fastapi.openapi.models.SecuritySchemeType",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"fastapi.openapi.models.APIKeyIn","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of APIKey","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.openapi.models.APIKey.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","type","description","in","name"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"fastapi.openapi.models.SecuritySchemeType",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"fastapi.openapi.models.APIKeyIn","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of APIKey","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"in_":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.APIKey.in_","name":"in_","setter_type":null,"type":"fastapi.openapi.models.APIKeyIn"}},"name":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.openapi.models.APIKey.name","name":"name","setter_type":null,"type":"builtins.str"}},"type_":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.APIKey.type_","name":"type_","setter_type":null,"type":"fastapi.openapi.models.SecuritySchemeType"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.APIKey.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.APIKey","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"APIKeyIn":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["enum.Enum"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.APIKeyIn","name":"APIKeyIn","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_enum"],"fullname":"fastapi.openapi.models.APIKeyIn","has_param_spec_type":false,"metaclass_type":"enum.EnumMeta","metadata":{},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.APIKeyIn","enum.Enum","builtins.object"],"names":{".class":"SymbolTable","cookie":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"fastapi.openapi.models.APIKeyIn.cookie","name":"cookie","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.str","value":"cookie"},"type_ref":"builtins.str"}}},"header":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"fastapi.openapi.models.APIKeyIn.header","name":"header","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.str","value":"header"},"type_ref":"builtins.str"}}},"query":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"fastapi.openapi.models.APIKeyIn.query","name":"query","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.str","value":"query"},"type_ref":"builtins.str"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.APIKeyIn.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.APIKeyIn","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Annotated":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Annotated","kind":"Gdef"},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"AnyUrl":{".class":"SymbolTableNode","cross_ref":"pydantic.networks.AnyUrl","kind":"Gdef"},"BaseModel":{".class":"SymbolTableNode","cross_ref":"pydantic.main.BaseModel","kind":"Gdef"},"BaseModelWithConfig":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.main.BaseModel"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.BaseModelWithConfig","name":"BaseModelWithConfig","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.BaseModelWithConfig","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.BaseModelWithConfig","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","Config":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.BaseModelWithConfig.Config","name":"Config","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.BaseModelWithConfig.Config","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.BaseModelWithConfig.Config","builtins.object"],"names":{".class":"SymbolTable","extra":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"fastapi.openapi.models.BaseModelWithConfig.Config.extra","name":"extra","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.BaseModelWithConfig.Config.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.BaseModelWithConfig.Config","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.openapi.models.BaseModelWithConfig.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.BaseModelWithConfig.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi.openapi.models.BaseModelWithConfig"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of BaseModelWithConfig","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.openapi.models.BaseModelWithConfig.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of BaseModelWithConfig","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.openapi.models.BaseModelWithConfig.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of BaseModelWithConfig","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"model_config":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready","is_inferred","has_explicit_value"],"fullname":"fastapi.openapi.models.BaseModelWithConfig.model_config","name":"model_config","setter_type":null,"type":{".class":"TypedDictType","fallback":"pydantic.config.ConfigDict","items":[["title",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],["model_title_generator",{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.type"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":true}],["field_title_generator",{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["builtins.str",{".class":"UnionType","items":["pydantic.fields.FieldInfo","pydantic.fields.ComputedFieldInfo"],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":true}],["str_to_lower","builtins.bool"],["str_to_upper","builtins.bool"],["str_strip_whitespace","builtins.bool"],["str_min_length","builtins.int"],["str_max_length",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],["extra",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.config.ExtraValues"},{".class":"NoneType"}],"uses_pep604_syntax":true}],["frozen","builtins.bool"],["populate_by_name","builtins.bool"],["use_enum_values","builtins.bool"],["validate_assignment","builtins.bool"],["arbitrary_types_allowed","builtins.bool"],["from_attributes","builtins.bool"],["loc_by_alias","builtins.bool"],["alias_generator",{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"pydantic.aliases.AliasGenerator",{".class":"NoneType"}],"uses_pep604_syntax":true}],["ignored_types",{".class":"Instance","args":["builtins.type"],"extra_attrs":null,"type_ref":"builtins.tuple"}],["allow_inf_nan","builtins.bool"],["json_schema_extra",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.config.JsonDict"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.config.JsonSchemaExtraCallable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],["json_encoders",{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeType","item":"builtins.object"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.config.JsonEncoder"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}],["strict","builtins.bool"],["revalidate_instances",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"always"},{".class":"LiteralType","fallback":"builtins.str","value":"never"},{".class":"LiteralType","fallback":"builtins.str","value":"subclass-instances"}],"uses_pep604_syntax":false}],["ser_json_timedelta",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"iso8601"},{".class":"LiteralType","fallback":"builtins.str","value":"float"}],"uses_pep604_syntax":false}],["ser_json_temporal",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"iso8601"},{".class":"LiteralType","fallback":"builtins.str","value":"seconds"},{".class":"LiteralType","fallback":"builtins.str","value":"milliseconds"}],"uses_pep604_syntax":false}],["val_temporal_unit",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"seconds"},{".class":"LiteralType","fallback":"builtins.str","value":"milliseconds"},{".class":"LiteralType","fallback":"builtins.str","value":"infer"}],"uses_pep604_syntax":false}],["ser_json_bytes",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"utf8"},{".class":"LiteralType","fallback":"builtins.str","value":"base64"},{".class":"LiteralType","fallback":"builtins.str","value":"hex"}],"uses_pep604_syntax":false}],["val_json_bytes",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"utf8"},{".class":"LiteralType","fallback":"builtins.str","value":"base64"},{".class":"LiteralType","fallback":"builtins.str","value":"hex"}],"uses_pep604_syntax":false}],["ser_json_inf_nan",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"null"},{".class":"LiteralType","fallback":"builtins.str","value":"constants"},{".class":"LiteralType","fallback":"builtins.str","value":"strings"}],"uses_pep604_syntax":false}],["validate_default","builtins.bool"],["validate_return","builtins.bool"],["protected_namespaces",{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}],["hide_input_in_errors","builtins.bool"],["defer_build","builtins.bool"],["plugin_settings",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","builtins.object"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}],["schema_generator",{".class":"UnionType","items":[{".class":"TypeType","item":"pydantic._internal._generate_schema.GenerateSchema"},{".class":"NoneType"}],"uses_pep604_syntax":true}],["json_schema_serialization_defaults_required","builtins.bool"],["json_schema_mode_override",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"validation"},{".class":"LiteralType","fallback":"builtins.str","value":"serialization"},{".class":"NoneType"}],"uses_pep604_syntax":false}],["coerce_numbers_to_str","builtins.bool"],["regex_engine",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"rust-regex"},{".class":"LiteralType","fallback":"builtins.str","value":"python-re"}],"uses_pep604_syntax":false}],["validation_error_cause","builtins.bool"],["use_attribute_docstrings","builtins.bool"],["cache_strings",{".class":"UnionType","items":["builtins.bool",{".class":"LiteralType","fallback":"builtins.str","value":"all"},{".class":"LiteralType","fallback":"builtins.str","value":"keys"},{".class":"LiteralType","fallback":"builtins.str","value":"none"}],"uses_pep604_syntax":true}],["validate_by_alias","builtins.bool"],["validate_by_name","builtins.bool"],["serialize_by_alias","builtins.bool"],["url_preserve_empty_path","builtins.bool"]],"readonly_keys":[],"required_keys":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.BaseModelWithConfig.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.BaseModelWithConfig","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"Components":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.openapi.models.BaseModelWithConfig"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.Components","name":"Components","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.Components","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":416,"name":"schemas","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Schema","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":417,"name":"responses","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Response","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":418,"name":"parameters","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Parameter","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":419,"name":"examples","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.Example"},"fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":420,"name":"requestBodies","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.RequestBody","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":421,"name":"headers","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Header","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":422,"name":"securitySchemes","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SecurityScheme"},"fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":423,"name":"links","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Link","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":425,"name":"callbacks","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.PathItem"],"extra_attrs":null,"type_ref":"builtins.dict"},"fastapi.openapi.models.Reference",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":426,"name":"pathItems","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.PathItem","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.Components","fastapi.openapi.models.BaseModelWithConfig","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.openapi.models.Components.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","schemas","responses","parameters","examples","requestBodies","headers","securitySchemes","links","callbacks","pathItems"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.Components.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","schemas","responses","parameters","examples","requestBodies","headers","securitySchemes","links","callbacks","pathItems"],"arg_types":["fastapi.openapi.models.Components",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Schema","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Response","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Parameter","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.Example"},"fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.RequestBody","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Header","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.APIKey","fastapi.openapi.models.HTTPBase","fastapi.openapi.models.OAuth2","fastapi.openapi.models.OpenIdConnect","fastapi.openapi.models.HTTPBearer","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Link","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.PathItem"],"extra_attrs":null,"type_ref":"builtins.dict"},"fastapi.openapi.models.Reference",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.PathItem","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of Components","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","schemas","responses","parameters","examples","requestBodies","headers","securitySchemes","links","callbacks","pathItems"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.openapi.models.Components.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","schemas","responses","parameters","examples","requestBodies","headers","securitySchemes","links","callbacks","pathItems"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Schema","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Response","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Parameter","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.Example"},"fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.RequestBody","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Header","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.APIKey","fastapi.openapi.models.HTTPBase","fastapi.openapi.models.OAuth2","fastapi.openapi.models.OpenIdConnect","fastapi.openapi.models.HTTPBearer","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Link","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.PathItem"],"extra_attrs":null,"type_ref":"builtins.dict"},"fastapi.openapi.models.Reference",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.PathItem","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of Components","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.openapi.models.Components.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","schemas","responses","parameters","examples","requestBodies","headers","securitySchemes","links","callbacks","pathItems"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Schema","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Response","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Parameter","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.Example"},"fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.RequestBody","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Header","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.APIKey","fastapi.openapi.models.HTTPBase","fastapi.openapi.models.OAuth2","fastapi.openapi.models.OpenIdConnect","fastapi.openapi.models.HTTPBearer","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Link","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.PathItem"],"extra_attrs":null,"type_ref":"builtins.dict"},"fastapi.openapi.models.Reference",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.PathItem","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of Components","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"callbacks":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Components.callbacks","name":"callbacks","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.PathItem"],"extra_attrs":null,"type_ref":"builtins.dict"},"fastapi.openapi.models.Reference",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"examples":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Components.examples","name":"examples","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.Example"},"fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"headers":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Components.headers","name":"headers","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Header","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"links":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Components.links","name":"links","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Link","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Components.parameters","name":"parameters","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Parameter","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"pathItems":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Components.pathItems","name":"pathItems","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.PathItem","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"requestBodies":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Components.requestBodies","name":"requestBodies","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.RequestBody","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"responses":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Components.responses","name":"responses","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Response","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"schemas":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Components.schemas","name":"schemas","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Schema","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"securitySchemes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Components.securitySchemes","name":"securitySchemes","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SecurityScheme"},"fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.Components.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.Components","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Contact":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.openapi.models.BaseModelWithConfig"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.Contact","name":"Contact","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.Contact","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":69,"name":"name","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":70,"name":"url","type":{".class":"UnionType","items":["pydantic.networks.AnyUrl",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":71,"name":"email","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.Contact","fastapi.openapi.models.BaseModelWithConfig","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.openapi.models.Contact.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5],"arg_names":["self","name","url","email"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.Contact.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":["self","name","url","email"],"arg_types":["fastapi.openapi.models.Contact",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["pydantic.networks.AnyUrl",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of Contact","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","name","url","email"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.openapi.models.Contact.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","name","url","email"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["pydantic.networks.AnyUrl",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of Contact","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.openapi.models.Contact.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","name","url","email"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["pydantic.networks.AnyUrl",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of Contact","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"email":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Contact.email","name":"email","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"name":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Contact.name","name":"name","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"url":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Contact.url","name":"url","setter_type":null,"type":{".class":"UnionType","items":["pydantic.networks.AnyUrl",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.Contact.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.Contact","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"CoreSchema":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.v1.CoreSchema","kind":"Gdef"},"Dict":{".class":"SymbolTableNode","cross_ref":"typing.Dict","kind":"Gdef"},"Discriminator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.main.BaseModel"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.Discriminator","name":"Discriminator","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.Discriminator","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":107,"name":"propertyName","type":"builtins.str"},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":108,"name":"mapping","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.Discriminator","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.openapi.models.Discriminator.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,5],"arg_names":["self","propertyName","mapping"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.Discriminator.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3,5],"arg_names":["self","propertyName","mapping"],"arg_types":["fastapi.openapi.models.Discriminator","builtins.str",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of Discriminator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","propertyName","mapping"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.openapi.models.Discriminator.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","propertyName","mapping"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of Discriminator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.openapi.models.Discriminator.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","propertyName","mapping"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of Discriminator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"mapping":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Discriminator.mapping","name":"mapping","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"propertyName":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.openapi.models.Discriminator.propertyName","name":"propertyName","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.Discriminator.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.Discriminator","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"EmailStr":{".class":"SymbolTableNode","cross_ref":"pydantic.networks.EmailStr","kind":"Gdef"},"Encoding":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.openapi.models.BaseModelWithConfig"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.Encoding","name":"Encoding","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.Encoding","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":245,"name":"contentType","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":246,"name":"headers","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Header","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":247,"name":"style","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":248,"name":"explode","type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":249,"name":"allowReserved","type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.Encoding","fastapi.openapi.models.BaseModelWithConfig","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.openapi.models.Encoding.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5,5],"arg_names":["self","contentType","headers","style","explode","allowReserved"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.Encoding.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5,5],"arg_names":["self","contentType","headers","style","explode","allowReserved"],"arg_types":["fastapi.openapi.models.Encoding",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Header","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of Encoding","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","contentType","headers","style","explode","allowReserved"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.openapi.models.Encoding.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","contentType","headers","style","explode","allowReserved"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Header","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of Encoding","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.openapi.models.Encoding.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","contentType","headers","style","explode","allowReserved"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Header","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of Encoding","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"allowReserved":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Encoding.allowReserved","name":"allowReserved","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"contentType":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Encoding.contentType","name":"contentType","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"explode":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Encoding.explode","name":"explode","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"headers":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Encoding.headers","name":"headers","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Header","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"style":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Encoding.style","name":"style","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.Encoding.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.Encoding","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Enum":{".class":"SymbolTableNode","cross_ref":"enum.Enum","kind":"Gdef"},"Example":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.Example","name":"Example","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.Example","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.Example","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["summary",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],["description",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],["value",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false}],["externalValue",{".class":"UnionType","items":["pydantic.networks.AnyUrl",{".class":"NoneType"}],"uses_pep604_syntax":false}]],"readonly_keys":[],"required_keys":[]}}},"ExternalDocumentation":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.openapi.models.BaseModelWithConfig"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.ExternalDocumentation","name":"ExternalDocumentation","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.ExternalDocumentation","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":120,"name":"description","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":121,"name":"url","type":"pydantic.networks.AnyUrl"}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.ExternalDocumentation","fastapi.openapi.models.BaseModelWithConfig","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.openapi.models.ExternalDocumentation.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,3],"arg_names":["self","description","url"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.ExternalDocumentation.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,3],"arg_names":["self","description","url"],"arg_types":["fastapi.openapi.models.ExternalDocumentation",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"pydantic.networks.AnyUrl"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of ExternalDocumentation","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","description","url"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.openapi.models.ExternalDocumentation.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","description","url"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"pydantic.networks.AnyUrl"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of ExternalDocumentation","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.openapi.models.ExternalDocumentation.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","description","url"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"pydantic.networks.AnyUrl"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of ExternalDocumentation","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"description":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.ExternalDocumentation.description","name":"description","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"url":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.openapi.models.ExternalDocumentation.url","name":"url","setter_type":null,"type":"pydantic.networks.AnyUrl"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.ExternalDocumentation.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.ExternalDocumentation","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Field":{".class":"SymbolTableNode","cross_ref":"pydantic.fields.Field","kind":"Gdef"},"GetJsonSchemaHandler":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.v1.GetJsonSchemaHandler","kind":"Gdef"},"HTTPBase":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.openapi.models.SecurityBase"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.HTTPBase","name":"HTTPBase","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.HTTPBase","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":"type","column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":362,"name":"type_","type":"fastapi.openapi.models.SecuritySchemeType"},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":346,"name":"description","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":363,"name":"scheme","type":"builtins.str"}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.HTTPBase","fastapi.openapi.models.SecurityBase","fastapi.openapi.models.BaseModelWithConfig","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.openapi.models.HTTPBase.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,3],"arg_names":["self","type","description","scheme"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.HTTPBase.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,5,3],"arg_names":["self","type","description","scheme"],"arg_types":["fastapi.openapi.models.HTTPBase","fastapi.openapi.models.SecuritySchemeType",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of HTTPBase","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","type","description","scheme"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.openapi.models.HTTPBase.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","type","description","scheme"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"fastapi.openapi.models.SecuritySchemeType",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of HTTPBase","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.openapi.models.HTTPBase.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","type","description","scheme"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"fastapi.openapi.models.SecuritySchemeType",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of HTTPBase","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"scheme":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.openapi.models.HTTPBase.scheme","name":"scheme","setter_type":null,"type":"builtins.str"}},"type_":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.HTTPBase.type_","name":"type_","setter_type":null,"type":"fastapi.openapi.models.SecuritySchemeType"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.HTTPBase.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.HTTPBase","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"HTTPBearer":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.openapi.models.HTTPBase"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.HTTPBearer","name":"HTTPBearer","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.HTTPBearer","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":"type","column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":362,"name":"type_","type":"fastapi.openapi.models.SecuritySchemeType"},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":346,"name":"description","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":367,"name":"scheme","type":{".class":"LiteralType","fallback":"builtins.str","value":"bearer"}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":368,"name":"bearerFormat","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.HTTPBearer","fastapi.openapi.models.HTTPBase","fastapi.openapi.models.SecurityBase","fastapi.openapi.models.BaseModelWithConfig","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.openapi.models.HTTPBearer.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5],"arg_names":["self","type","description","scheme","bearerFormat"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.HTTPBearer.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":["self","type","description","scheme","bearerFormat"],"arg_types":["fastapi.openapi.models.HTTPBearer","fastapi.openapi.models.SecuritySchemeType",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"LiteralType","fallback":"builtins.str","value":"bearer"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of HTTPBearer","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","type","description","scheme","bearerFormat"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.openapi.models.HTTPBearer.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","type","description","scheme","bearerFormat"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"fastapi.openapi.models.SecuritySchemeType",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"LiteralType","fallback":"builtins.str","value":"bearer"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of HTTPBearer","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.openapi.models.HTTPBearer.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","type","description","scheme","bearerFormat"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"fastapi.openapi.models.SecuritySchemeType",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"LiteralType","fallback":"builtins.str","value":"bearer"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of HTTPBearer","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"bearerFormat":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.HTTPBearer.bearerFormat","name":"bearerFormat","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"scheme":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.HTTPBearer.scheme","name":"scheme","setter_type":null,"type":{".class":"LiteralType","fallback":"builtins.str","value":"bearer"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.HTTPBearer.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.HTTPBearer","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Header":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.openapi.models.ParameterBase"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.Header","name":"Header","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.Header","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":260,"name":"description","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":261,"name":"required","type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":262,"name":"deprecated","type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":264,"name":"style","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":265,"name":"explode","type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":266,"name":"allowReserved","type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":"schema","column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":267,"name":"schema_","type":{".class":"UnionType","items":["fastapi.openapi.models.Schema","fastapi.openapi.models.Reference",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":268,"name":"example","type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":269,"name":"examples","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.Example"},"fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":271,"name":"content","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.MediaType"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.Header","fastapi.openapi.models.ParameterBase","fastapi.openapi.models.BaseModelWithConfig","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.openapi.models.Header.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","description","required","deprecated","style","explode","allowReserved","schema","example","examples","content"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.Header.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","description","required","deprecated","style","explode","allowReserved","schema","example","examples","content"],"arg_types":["fastapi.openapi.models.Header",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","fastapi.openapi.models.Reference",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.Example"},"fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.MediaType"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of Header","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","description","required","deprecated","style","explode","allowReserved","schema","example","examples","content"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.openapi.models.Header.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","description","required","deprecated","style","explode","allowReserved","schema","example","examples","content"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","fastapi.openapi.models.Reference",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.Example"},"fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.MediaType"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of Header","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.openapi.models.Header.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","description","required","deprecated","style","explode","allowReserved","schema","example","examples","content"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","fastapi.openapi.models.Reference",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.Example"},"fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.MediaType"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of Header","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.Header.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.Header","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Info":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.openapi.models.BaseModelWithConfig"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.Info","name":"Info","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.Info","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":81,"name":"title","type":"builtins.str"},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":82,"name":"summary","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":83,"name":"description","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":84,"name":"termsOfService","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":85,"name":"contact","type":{".class":"UnionType","items":["fastapi.openapi.models.Contact",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":86,"name":"license","type":{".class":"UnionType","items":["fastapi.openapi.models.License",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":87,"name":"version","type":"builtins.str"}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.Info","fastapi.openapi.models.BaseModelWithConfig","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.openapi.models.Info.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,5,5,5,5,5,3],"arg_names":["self","title","summary","description","termsOfService","contact","license","version"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.Info.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3,5,5,5,5,5,3],"arg_names":["self","title","summary","description","termsOfService","contact","license","version"],"arg_types":["fastapi.openapi.models.Info","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Contact",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.License",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of Info","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","title","summary","description","termsOfService","contact","license","version"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.openapi.models.Info.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","title","summary","description","termsOfService","contact","license","version"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Contact",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.License",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of Info","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.openapi.models.Info.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","title","summary","description","termsOfService","contact","license","version"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Contact",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.License",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of Info","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"contact":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Info.contact","name":"contact","setter_type":null,"type":{".class":"UnionType","items":["fastapi.openapi.models.Contact",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"description":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Info.description","name":"description","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"license":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Info.license","name":"license","setter_type":null,"type":{".class":"UnionType","items":["fastapi.openapi.models.License",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"summary":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Info.summary","name":"summary","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"termsOfService":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Info.termsOfService","name":"termsOfService","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"title":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.openapi.models.Info.title","name":"title","setter_type":null,"type":"builtins.str"}},"version":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.openapi.models.Info.version","name":"version","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.Info.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.Info","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef"},"JsonSchemaValue":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.v1.JsonSchemaValue","kind":"Gdef"},"License":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.openapi.models.BaseModelWithConfig"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.License","name":"License","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.License","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":75,"name":"name","type":"builtins.str"},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":76,"name":"identifier","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":77,"name":"url","type":{".class":"UnionType","items":["pydantic.networks.AnyUrl",{".class":"NoneType"}],"uses_pep604_syntax":false}}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.License","fastapi.openapi.models.BaseModelWithConfig","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.openapi.models.License.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,5,5],"arg_names":["self","name","identifier","url"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.License.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3,5,5],"arg_names":["self","name","identifier","url"],"arg_types":["fastapi.openapi.models.License","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["pydantic.networks.AnyUrl",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of License","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","name","identifier","url"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.openapi.models.License.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","name","identifier","url"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["pydantic.networks.AnyUrl",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of License","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.openapi.models.License.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","name","identifier","url"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["pydantic.networks.AnyUrl",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of License","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"identifier":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.License.identifier","name":"identifier","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"name":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.openapi.models.License.name","name":"name","setter_type":null,"type":"builtins.str"}},"url":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.License.url","name":"url","setter_type":null,"type":{".class":"UnionType","items":["pydantic.networks.AnyUrl",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.License.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.License","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Link":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.openapi.models.BaseModelWithConfig"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.Link","name":"Link","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.Link","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":290,"name":"operationRef","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":291,"name":"operationId","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":292,"name":"parameters","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"builtins.str"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":293,"name":"requestBody","type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":294,"name":"description","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":295,"name":"server","type":{".class":"UnionType","items":["fastapi.openapi.models.Server",{".class":"NoneType"}],"uses_pep604_syntax":false}}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.Link","fastapi.openapi.models.BaseModelWithConfig","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.openapi.models.Link.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5,5,5],"arg_names":["self","operationRef","operationId","parameters","requestBody","description","server"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.Link.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5,5,5],"arg_names":["self","operationRef","operationId","parameters","requestBody","description","server"],"arg_types":["fastapi.openapi.models.Link",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"builtins.str"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Server",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of Link","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","operationRef","operationId","parameters","requestBody","description","server"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.openapi.models.Link.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","operationRef","operationId","parameters","requestBody","description","server"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"builtins.str"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Server",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of Link","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.openapi.models.Link.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","operationRef","operationId","parameters","requestBody","description","server"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"builtins.str"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Server",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of Link","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"description":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Link.description","name":"description","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"operationId":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Link.operationId","name":"operationId","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"operationRef":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Link.operationRef","name":"operationRef","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Link.parameters","name":"parameters","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"builtins.str"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"requestBody":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Link.requestBody","name":"requestBody","setter_type":null,"type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"server":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Link.server","name":"server","setter_type":null,"type":{".class":"UnionType","items":["fastapi.openapi.models.Server",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.Link.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.Link","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"List":{".class":"SymbolTableNode","cross_ref":"typing.List","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Literal","kind":"Gdef"},"MediaType":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.openapi.models.BaseModelWithConfig"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.MediaType","name":"MediaType","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.MediaType","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":"schema","column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":253,"name":"schema_","type":{".class":"UnionType","items":["fastapi.openapi.models.Schema","fastapi.openapi.models.Reference",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":254,"name":"example","type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":255,"name":"examples","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.Example"},"fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":256,"name":"encoding","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.Encoding"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.MediaType","fastapi.openapi.models.BaseModelWithConfig","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.openapi.models.MediaType.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5],"arg_names":["self","schema","example","examples","encoding"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.MediaType.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":["self","schema","example","examples","encoding"],"arg_types":["fastapi.openapi.models.MediaType",{".class":"UnionType","items":["fastapi.openapi.models.Schema","fastapi.openapi.models.Reference",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.Example"},"fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.Encoding"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of MediaType","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","schema","example","examples","encoding"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.openapi.models.MediaType.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","schema","example","examples","encoding"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","fastapi.openapi.models.Reference",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.Example"},"fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.Encoding"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of MediaType","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.openapi.models.MediaType.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","schema","example","examples","encoding"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","fastapi.openapi.models.Reference",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.Example"},"fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.Encoding"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of MediaType","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"encoding":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.MediaType.encoding","name":"encoding","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.Encoding"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"example":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.MediaType.example","name":"example","setter_type":null,"type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"examples":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.MediaType.examples","name":"examples","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.Example"},"fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"schema_":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.MediaType.schema_","name":"schema_","setter_type":null,"type":{".class":"UnionType","items":["fastapi.openapi.models.Schema","fastapi.openapi.models.Reference",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.MediaType.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.MediaType","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"OAuth2":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.openapi.models.SecurityBase"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.OAuth2","name":"OAuth2","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.OAuth2","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":"type","column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":401,"name":"type_","type":"fastapi.openapi.models.SecuritySchemeType"},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":346,"name":"description","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":402,"name":"flows","type":"fastapi.openapi.models.OAuthFlows"}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.OAuth2","fastapi.openapi.models.SecurityBase","fastapi.openapi.models.BaseModelWithConfig","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.openapi.models.OAuth2.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,3],"arg_names":["self","type","description","flows"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.OAuth2.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,5,3],"arg_names":["self","type","description","flows"],"arg_types":["fastapi.openapi.models.OAuth2","fastapi.openapi.models.SecuritySchemeType",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"fastapi.openapi.models.OAuthFlows"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of OAuth2","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","type","description","flows"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.openapi.models.OAuth2.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","type","description","flows"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"fastapi.openapi.models.SecuritySchemeType",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"fastapi.openapi.models.OAuthFlows"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of OAuth2","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.openapi.models.OAuth2.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","type","description","flows"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"fastapi.openapi.models.SecuritySchemeType",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"fastapi.openapi.models.OAuthFlows"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of OAuth2","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"flows":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.openapi.models.OAuth2.flows","name":"flows","setter_type":null,"type":"fastapi.openapi.models.OAuthFlows"}},"type_":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.OAuth2.type_","name":"type_","setter_type":null,"type":"fastapi.openapi.models.SecuritySchemeType"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.OAuth2.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.OAuth2","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"OAuthFlow":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.openapi.models.BaseModelWithConfig"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.OAuthFlow","name":"OAuthFlow","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.OAuthFlow","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":372,"name":"refreshUrl","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":373,"name":"scopes","type":{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.OAuthFlow","fastapi.openapi.models.BaseModelWithConfig","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.openapi.models.OAuthFlow.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5],"arg_names":["self","refreshUrl","scopes"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.OAuthFlow.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":["self","refreshUrl","scopes"],"arg_types":["fastapi.openapi.models.OAuthFlow",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of OAuthFlow","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","refreshUrl","scopes"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.openapi.models.OAuthFlow.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","refreshUrl","scopes"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of OAuthFlow","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.openapi.models.OAuthFlow.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","refreshUrl","scopes"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of OAuthFlow","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"refreshUrl":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.OAuthFlow.refreshUrl","name":"refreshUrl","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"scopes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.OAuthFlow.scopes","name":"scopes","setter_type":null,"type":{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.OAuthFlow.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.OAuthFlow","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"OAuthFlowAuthorizationCode":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.openapi.models.OAuthFlow"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.OAuthFlowAuthorizationCode","name":"OAuthFlowAuthorizationCode","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.OAuthFlowAuthorizationCode","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":372,"name":"refreshUrl","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":373,"name":"scopes","type":{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":389,"name":"authorizationUrl","type":"builtins.str"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":390,"name":"tokenUrl","type":"builtins.str"}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.OAuthFlowAuthorizationCode","fastapi.openapi.models.OAuthFlow","fastapi.openapi.models.BaseModelWithConfig","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.openapi.models.OAuthFlowAuthorizationCode.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,3,3],"arg_names":["self","refreshUrl","scopes","authorizationUrl","tokenUrl"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.OAuthFlowAuthorizationCode.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,5,3,3],"arg_names":["self","refreshUrl","scopes","authorizationUrl","tokenUrl"],"arg_types":["fastapi.openapi.models.OAuthFlowAuthorizationCode",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of OAuthFlowAuthorizationCode","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","refreshUrl","scopes","authorizationUrl","tokenUrl"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.openapi.models.OAuthFlowAuthorizationCode.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","refreshUrl","scopes","authorizationUrl","tokenUrl"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of OAuthFlowAuthorizationCode","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.openapi.models.OAuthFlowAuthorizationCode.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","refreshUrl","scopes","authorizationUrl","tokenUrl"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of OAuthFlowAuthorizationCode","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"authorizationUrl":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.openapi.models.OAuthFlowAuthorizationCode.authorizationUrl","name":"authorizationUrl","setter_type":null,"type":"builtins.str"}},"tokenUrl":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.openapi.models.OAuthFlowAuthorizationCode.tokenUrl","name":"tokenUrl","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.OAuthFlowAuthorizationCode.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.OAuthFlowAuthorizationCode","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"OAuthFlowClientCredentials":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.openapi.models.OAuthFlow"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.OAuthFlowClientCredentials","name":"OAuthFlowClientCredentials","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.OAuthFlowClientCredentials","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":372,"name":"refreshUrl","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":373,"name":"scopes","type":{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":385,"name":"tokenUrl","type":"builtins.str"}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.OAuthFlowClientCredentials","fastapi.openapi.models.OAuthFlow","fastapi.openapi.models.BaseModelWithConfig","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.openapi.models.OAuthFlowClientCredentials.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,3],"arg_names":["self","refreshUrl","scopes","tokenUrl"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.OAuthFlowClientCredentials.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,5,3],"arg_names":["self","refreshUrl","scopes","tokenUrl"],"arg_types":["fastapi.openapi.models.OAuthFlowClientCredentials",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of OAuthFlowClientCredentials","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","refreshUrl","scopes","tokenUrl"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.openapi.models.OAuthFlowClientCredentials.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","refreshUrl","scopes","tokenUrl"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of OAuthFlowClientCredentials","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.openapi.models.OAuthFlowClientCredentials.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","refreshUrl","scopes","tokenUrl"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of OAuthFlowClientCredentials","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"tokenUrl":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.openapi.models.OAuthFlowClientCredentials.tokenUrl","name":"tokenUrl","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.OAuthFlowClientCredentials.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.OAuthFlowClientCredentials","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"OAuthFlowImplicit":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.openapi.models.OAuthFlow"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.OAuthFlowImplicit","name":"OAuthFlowImplicit","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.OAuthFlowImplicit","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":372,"name":"refreshUrl","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":373,"name":"scopes","type":{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":377,"name":"authorizationUrl","type":"builtins.str"}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.OAuthFlowImplicit","fastapi.openapi.models.OAuthFlow","fastapi.openapi.models.BaseModelWithConfig","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.openapi.models.OAuthFlowImplicit.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,3],"arg_names":["self","refreshUrl","scopes","authorizationUrl"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.OAuthFlowImplicit.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,5,3],"arg_names":["self","refreshUrl","scopes","authorizationUrl"],"arg_types":["fastapi.openapi.models.OAuthFlowImplicit",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of OAuthFlowImplicit","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","refreshUrl","scopes","authorizationUrl"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.openapi.models.OAuthFlowImplicit.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","refreshUrl","scopes","authorizationUrl"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of OAuthFlowImplicit","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.openapi.models.OAuthFlowImplicit.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","refreshUrl","scopes","authorizationUrl"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of OAuthFlowImplicit","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"authorizationUrl":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.openapi.models.OAuthFlowImplicit.authorizationUrl","name":"authorizationUrl","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.OAuthFlowImplicit.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.OAuthFlowImplicit","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"OAuthFlowPassword":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.openapi.models.OAuthFlow"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.OAuthFlowPassword","name":"OAuthFlowPassword","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.OAuthFlowPassword","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":372,"name":"refreshUrl","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":373,"name":"scopes","type":{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":381,"name":"tokenUrl","type":"builtins.str"}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.OAuthFlowPassword","fastapi.openapi.models.OAuthFlow","fastapi.openapi.models.BaseModelWithConfig","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.openapi.models.OAuthFlowPassword.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,3],"arg_names":["self","refreshUrl","scopes","tokenUrl"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.OAuthFlowPassword.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,5,3],"arg_names":["self","refreshUrl","scopes","tokenUrl"],"arg_types":["fastapi.openapi.models.OAuthFlowPassword",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of OAuthFlowPassword","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","refreshUrl","scopes","tokenUrl"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.openapi.models.OAuthFlowPassword.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","refreshUrl","scopes","tokenUrl"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of OAuthFlowPassword","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.openapi.models.OAuthFlowPassword.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","refreshUrl","scopes","tokenUrl"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of OAuthFlowPassword","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"tokenUrl":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.openapi.models.OAuthFlowPassword.tokenUrl","name":"tokenUrl","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.OAuthFlowPassword.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.OAuthFlowPassword","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"OAuthFlows":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.openapi.models.BaseModelWithConfig"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.OAuthFlows","name":"OAuthFlows","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.OAuthFlows","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":394,"name":"implicit","type":{".class":"UnionType","items":["fastapi.openapi.models.OAuthFlowImplicit",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":395,"name":"password","type":{".class":"UnionType","items":["fastapi.openapi.models.OAuthFlowPassword",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":396,"name":"clientCredentials","type":{".class":"UnionType","items":["fastapi.openapi.models.OAuthFlowClientCredentials",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":397,"name":"authorizationCode","type":{".class":"UnionType","items":["fastapi.openapi.models.OAuthFlowAuthorizationCode",{".class":"NoneType"}],"uses_pep604_syntax":false}}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.OAuthFlows","fastapi.openapi.models.BaseModelWithConfig","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.openapi.models.OAuthFlows.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5],"arg_names":["self","implicit","password","clientCredentials","authorizationCode"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.OAuthFlows.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":["self","implicit","password","clientCredentials","authorizationCode"],"arg_types":["fastapi.openapi.models.OAuthFlows",{".class":"UnionType","items":["fastapi.openapi.models.OAuthFlowImplicit",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.OAuthFlowPassword",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.OAuthFlowClientCredentials",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.OAuthFlowAuthorizationCode",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of OAuthFlows","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","implicit","password","clientCredentials","authorizationCode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.openapi.models.OAuthFlows.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","implicit","password","clientCredentials","authorizationCode"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.OAuthFlowImplicit",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.OAuthFlowPassword",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.OAuthFlowClientCredentials",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.OAuthFlowAuthorizationCode",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of OAuthFlows","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.openapi.models.OAuthFlows.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","implicit","password","clientCredentials","authorizationCode"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.OAuthFlowImplicit",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.OAuthFlowPassword",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.OAuthFlowClientCredentials",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.OAuthFlowAuthorizationCode",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of OAuthFlows","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"authorizationCode":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.OAuthFlows.authorizationCode","name":"authorizationCode","setter_type":null,"type":{".class":"UnionType","items":["fastapi.openapi.models.OAuthFlowAuthorizationCode",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"clientCredentials":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.OAuthFlows.clientCredentials","name":"clientCredentials","setter_type":null,"type":{".class":"UnionType","items":["fastapi.openapi.models.OAuthFlowClientCredentials",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"implicit":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.OAuthFlows.implicit","name":"implicit","setter_type":null,"type":{".class":"UnionType","items":["fastapi.openapi.models.OAuthFlowImplicit",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"password":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.OAuthFlows.password","name":"password","setter_type":null,"type":{".class":"UnionType","items":["fastapi.openapi.models.OAuthFlowPassword",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.OAuthFlows.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.OAuthFlows","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"OpenAPI":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.openapi.models.BaseModelWithConfig"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.OpenAPI","name":"OpenAPI","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.OpenAPI","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":436,"name":"openapi","type":"builtins.str"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":437,"name":"info","type":"fastapi.openapi.models.Info"},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":438,"name":"jsonSchemaDialect","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":439,"name":"servers","type":{".class":"UnionType","items":[{".class":"Instance","args":["fastapi.openapi.models.Server"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":441,"name":"paths","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.PathItem",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":442,"name":"webhooks","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.PathItem","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":443,"name":"components","type":{".class":"UnionType","items":["fastapi.openapi.models.Components",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":444,"name":"security","type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"builtins.dict"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":445,"name":"tags","type":{".class":"UnionType","items":[{".class":"Instance","args":["fastapi.openapi.models.Tag"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":446,"name":"externalDocs","type":{".class":"UnionType","items":["fastapi.openapi.models.ExternalDocumentation",{".class":"NoneType"}],"uses_pep604_syntax":false}}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.OpenAPI","fastapi.openapi.models.BaseModelWithConfig","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.openapi.models.OpenAPI.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,3,5,5,5,5,5,5,5,5],"arg_names":["self","openapi","info","jsonSchemaDialect","servers","paths","webhooks","components","security","tags","externalDocs"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.OpenAPI.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3,3,5,5,5,5,5,5,5,5],"arg_names":["self","openapi","info","jsonSchemaDialect","servers","paths","webhooks","components","security","tags","externalDocs"],"arg_types":["fastapi.openapi.models.OpenAPI","builtins.str","fastapi.openapi.models.Info",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["fastapi.openapi.models.Server"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.PathItem",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.PathItem","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Components",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"builtins.dict"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["fastapi.openapi.models.Tag"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.ExternalDocumentation",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of OpenAPI","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","openapi","info","jsonSchemaDialect","servers","paths","webhooks","components","security","tags","externalDocs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.openapi.models.OpenAPI.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","openapi","info","jsonSchemaDialect","servers","paths","webhooks","components","security","tags","externalDocs"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str","fastapi.openapi.models.Info",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["fastapi.openapi.models.Server"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.PathItem",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.PathItem","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Components",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"builtins.dict"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["fastapi.openapi.models.Tag"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.ExternalDocumentation",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of OpenAPI","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.openapi.models.OpenAPI.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","openapi","info","jsonSchemaDialect","servers","paths","webhooks","components","security","tags","externalDocs"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str","fastapi.openapi.models.Info",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["fastapi.openapi.models.Server"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.PathItem",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.PathItem","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Components",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"builtins.dict"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["fastapi.openapi.models.Tag"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.ExternalDocumentation",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of OpenAPI","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"components":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.OpenAPI.components","name":"components","setter_type":null,"type":{".class":"UnionType","items":["fastapi.openapi.models.Components",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"externalDocs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.OpenAPI.externalDocs","name":"externalDocs","setter_type":null,"type":{".class":"UnionType","items":["fastapi.openapi.models.ExternalDocumentation",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"info":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.openapi.models.OpenAPI.info","name":"info","setter_type":null,"type":"fastapi.openapi.models.Info"}},"jsonSchemaDialect":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.OpenAPI.jsonSchemaDialect","name":"jsonSchemaDialect","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"openapi":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.openapi.models.OpenAPI.openapi","name":"openapi","setter_type":null,"type":"builtins.str"}},"paths":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.OpenAPI.paths","name":"paths","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.PathItem",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"security":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.OpenAPI.security","name":"security","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"builtins.dict"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"servers":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.OpenAPI.servers","name":"servers","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["fastapi.openapi.models.Server"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"tags":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.OpenAPI.tags","name":"tags","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["fastapi.openapi.models.Tag"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"webhooks":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.OpenAPI.webhooks","name":"webhooks","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.PathItem","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.OpenAPI.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.OpenAPI","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"OpenIdConnect":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.openapi.models.SecurityBase"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.OpenIdConnect","name":"OpenIdConnect","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.OpenIdConnect","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":"type","column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":406,"name":"type_","type":"fastapi.openapi.models.SecuritySchemeType"},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":346,"name":"description","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":409,"name":"openIdConnectUrl","type":"builtins.str"}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.OpenIdConnect","fastapi.openapi.models.SecurityBase","fastapi.openapi.models.BaseModelWithConfig","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.openapi.models.OpenIdConnect.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,3],"arg_names":["self","type","description","openIdConnectUrl"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.OpenIdConnect.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,5,3],"arg_names":["self","type","description","openIdConnectUrl"],"arg_types":["fastapi.openapi.models.OpenIdConnect","fastapi.openapi.models.SecuritySchemeType",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of OpenIdConnect","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","type","description","openIdConnectUrl"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.openapi.models.OpenIdConnect.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","type","description","openIdConnectUrl"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"fastapi.openapi.models.SecuritySchemeType",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of OpenIdConnect","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.openapi.models.OpenIdConnect.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","type","description","openIdConnectUrl"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"fastapi.openapi.models.SecuritySchemeType",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of OpenIdConnect","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"openIdConnectUrl":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.openapi.models.OpenIdConnect.openIdConnectUrl","name":"openIdConnectUrl","setter_type":null,"type":"builtins.str"}},"type_":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.OpenIdConnect.type_","name":"type_","setter_type":null,"type":"fastapi.openapi.models.SecuritySchemeType"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.OpenIdConnect.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.OpenIdConnect","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Operation":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.openapi.models.BaseModelWithConfig"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.Operation","name":"Operation","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.Operation","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":306,"name":"tags","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":307,"name":"summary","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":308,"name":"description","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":309,"name":"externalDocs","type":{".class":"UnionType","items":["fastapi.openapi.models.ExternalDocumentation",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":310,"name":"operationId","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":311,"name":"parameters","type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":["fastapi.openapi.models.Parameter","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":312,"name":"requestBody","type":{".class":"UnionType","items":["fastapi.openapi.models.RequestBody","fastapi.openapi.models.Reference",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":314,"name":"responses","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Response",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":315,"name":"callbacks","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.PathItem"],"extra_attrs":null,"type_ref":"builtins.dict"},"fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":316,"name":"deprecated","type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":317,"name":"security","type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"builtins.dict"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":318,"name":"servers","type":{".class":"UnionType","items":[{".class":"Instance","args":["fastapi.openapi.models.Server"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.Operation","fastapi.openapi.models.BaseModelWithConfig","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.openapi.models.Operation.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","tags","summary","description","externalDocs","operationId","parameters","requestBody","responses","callbacks","deprecated","security","servers"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.Operation.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","tags","summary","description","externalDocs","operationId","parameters","requestBody","responses","callbacks","deprecated","security","servers"],"arg_types":["fastapi.openapi.models.Operation",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.ExternalDocumentation",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":["fastapi.openapi.models.Parameter","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.RequestBody","fastapi.openapi.models.Reference",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Response",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.PathItem"],"extra_attrs":null,"type_ref":"builtins.dict"},"fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"builtins.dict"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["fastapi.openapi.models.Server"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of Operation","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","tags","summary","description","externalDocs","operationId","parameters","requestBody","responses","callbacks","deprecated","security","servers"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.openapi.models.Operation.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","tags","summary","description","externalDocs","operationId","parameters","requestBody","responses","callbacks","deprecated","security","servers"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.ExternalDocumentation",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":["fastapi.openapi.models.Parameter","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.RequestBody","fastapi.openapi.models.Reference",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Response",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.PathItem"],"extra_attrs":null,"type_ref":"builtins.dict"},"fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"builtins.dict"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["fastapi.openapi.models.Server"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of Operation","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.openapi.models.Operation.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","tags","summary","description","externalDocs","operationId","parameters","requestBody","responses","callbacks","deprecated","security","servers"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.ExternalDocumentation",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":["fastapi.openapi.models.Parameter","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.RequestBody","fastapi.openapi.models.Reference",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Response",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.PathItem"],"extra_attrs":null,"type_ref":"builtins.dict"},"fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"builtins.dict"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["fastapi.openapi.models.Server"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of Operation","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"callbacks":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Operation.callbacks","name":"callbacks","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.PathItem"],"extra_attrs":null,"type_ref":"builtins.dict"},"fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"deprecated":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Operation.deprecated","name":"deprecated","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"description":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Operation.description","name":"description","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"externalDocs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Operation.externalDocs","name":"externalDocs","setter_type":null,"type":{".class":"UnionType","items":["fastapi.openapi.models.ExternalDocumentation",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"operationId":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Operation.operationId","name":"operationId","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Operation.parameters","name":"parameters","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":["fastapi.openapi.models.Parameter","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"requestBody":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Operation.requestBody","name":"requestBody","setter_type":null,"type":{".class":"UnionType","items":["fastapi.openapi.models.RequestBody","fastapi.openapi.models.Reference",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"responses":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Operation.responses","name":"responses","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Response",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"security":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Operation.security","name":"security","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"builtins.dict"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"servers":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Operation.servers","name":"servers","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["fastapi.openapi.models.Server"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"summary":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Operation.summary","name":"summary","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"tags":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Operation.tags","name":"tags","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.Operation.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.Operation","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"PYDANTIC_V2":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.shared.PYDANTIC_V2","kind":"Gdef"},"Parameter":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.openapi.models.ParameterBase"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.Parameter","name":"Parameter","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.Parameter","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":260,"name":"description","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":261,"name":"required","type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":262,"name":"deprecated","type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":264,"name":"style","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":265,"name":"explode","type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":266,"name":"allowReserved","type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":"schema","column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":267,"name":"schema_","type":{".class":"UnionType","items":["fastapi.openapi.models.Schema","fastapi.openapi.models.Reference",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":268,"name":"example","type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":269,"name":"examples","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.Example"},"fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":271,"name":"content","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.MediaType"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":275,"name":"name","type":"builtins.str"},{"alias":"in","column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":276,"name":"in_","type":"fastapi.openapi.models.ParameterInType"}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.Parameter","fastapi.openapi.models.ParameterBase","fastapi.openapi.models.BaseModelWithConfig","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.openapi.models.Parameter.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5,5,5,5,5,5,5,3,3],"arg_names":["self","description","required","deprecated","style","explode","allowReserved","schema","example","examples","content","name","in"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.Parameter.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5,5,5,5,5,5,5,3,3],"arg_names":["self","description","required","deprecated","style","explode","allowReserved","schema","example","examples","content","name","in"],"arg_types":["fastapi.openapi.models.Parameter",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","fastapi.openapi.models.Reference",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.Example"},"fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.MediaType"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str","fastapi.openapi.models.ParameterInType"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of Parameter","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","description","required","deprecated","style","explode","allowReserved","schema","example","examples","content","name","in"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.openapi.models.Parameter.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","description","required","deprecated","style","explode","allowReserved","schema","example","examples","content","name","in"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","fastapi.openapi.models.Reference",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.Example"},"fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.MediaType"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str","fastapi.openapi.models.ParameterInType"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of Parameter","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.openapi.models.Parameter.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","description","required","deprecated","style","explode","allowReserved","schema","example","examples","content","name","in"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","fastapi.openapi.models.Reference",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.Example"},"fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.MediaType"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str","fastapi.openapi.models.ParameterInType"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of Parameter","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"in_":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Parameter.in_","name":"in_","setter_type":null,"type":"fastapi.openapi.models.ParameterInType"}},"name":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.openapi.models.Parameter.name","name":"name","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.Parameter.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.Parameter","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ParameterBase":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.openapi.models.BaseModelWithConfig"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.ParameterBase","name":"ParameterBase","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.ParameterBase","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":260,"name":"description","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":261,"name":"required","type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":262,"name":"deprecated","type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":264,"name":"style","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":265,"name":"explode","type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":266,"name":"allowReserved","type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":"schema","column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":267,"name":"schema_","type":{".class":"UnionType","items":["fastapi.openapi.models.Schema","fastapi.openapi.models.Reference",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":268,"name":"example","type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":269,"name":"examples","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.Example"},"fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":271,"name":"content","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.MediaType"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.ParameterBase","fastapi.openapi.models.BaseModelWithConfig","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.openapi.models.ParameterBase.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","description","required","deprecated","style","explode","allowReserved","schema","example","examples","content"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.ParameterBase.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","description","required","deprecated","style","explode","allowReserved","schema","example","examples","content"],"arg_types":["fastapi.openapi.models.ParameterBase",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","fastapi.openapi.models.Reference",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.Example"},"fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.MediaType"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of ParameterBase","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","description","required","deprecated","style","explode","allowReserved","schema","example","examples","content"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.openapi.models.ParameterBase.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","description","required","deprecated","style","explode","allowReserved","schema","example","examples","content"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","fastapi.openapi.models.Reference",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.Example"},"fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.MediaType"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of ParameterBase","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.openapi.models.ParameterBase.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","description","required","deprecated","style","explode","allowReserved","schema","example","examples","content"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","fastapi.openapi.models.Reference",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.Example"},"fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.MediaType"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of ParameterBase","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"allowReserved":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.ParameterBase.allowReserved","name":"allowReserved","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"content":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.ParameterBase.content","name":"content","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.MediaType"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"deprecated":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.ParameterBase.deprecated","name":"deprecated","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"description":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.ParameterBase.description","name":"description","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"example":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.ParameterBase.example","name":"example","setter_type":null,"type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"examples":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.ParameterBase.examples","name":"examples","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.Example"},"fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"explode":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.ParameterBase.explode","name":"explode","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"required":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.ParameterBase.required","name":"required","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"schema_":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.ParameterBase.schema_","name":"schema_","setter_type":null,"type":{".class":"UnionType","items":["fastapi.openapi.models.Schema","fastapi.openapi.models.Reference",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"style":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.ParameterBase.style","name":"style","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.ParameterBase.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.ParameterBase","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ParameterInType":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["enum.Enum"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.ParameterInType","name":"ParameterInType","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_enum"],"fullname":"fastapi.openapi.models.ParameterInType","has_param_spec_type":false,"metaclass_type":"enum.EnumMeta","metadata":{},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.ParameterInType","enum.Enum","builtins.object"],"names":{".class":"SymbolTable","cookie":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"fastapi.openapi.models.ParameterInType.cookie","name":"cookie","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.str","value":"cookie"},"type_ref":"builtins.str"}}},"header":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"fastapi.openapi.models.ParameterInType.header","name":"header","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.str","value":"header"},"type_ref":"builtins.str"}}},"path":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"fastapi.openapi.models.ParameterInType.path","name":"path","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.str","value":"path"},"type_ref":"builtins.str"}}},"query":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"fastapi.openapi.models.ParameterInType.query","name":"query","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.str","value":"query"},"type_ref":"builtins.str"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.ParameterInType.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.ParameterInType","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"PathItem":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.openapi.models.BaseModelWithConfig"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.PathItem","name":"PathItem","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.PathItem","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":"$ref","column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":322,"name":"ref","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":323,"name":"summary","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":324,"name":"description","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":325,"name":"get","type":{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":326,"name":"put","type":{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":327,"name":"post","type":{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":328,"name":"delete","type":{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":329,"name":"options","type":{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":330,"name":"head","type":{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":331,"name":"patch","type":{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":332,"name":"trace","type":{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":333,"name":"servers","type":{".class":"UnionType","items":[{".class":"Instance","args":["fastapi.openapi.models.Server"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":334,"name":"parameters","type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":["fastapi.openapi.models.Parameter","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.PathItem","fastapi.openapi.models.BaseModelWithConfig","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.openapi.models.PathItem.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","$ref","summary","description","get","put","post","delete","options","head","patch","trace","servers","parameters"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.PathItem.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","$ref","summary","description","get","put","post","delete","options","head","patch","trace","servers","parameters"],"arg_types":["fastapi.openapi.models.PathItem",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["fastapi.openapi.models.Server"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":["fastapi.openapi.models.Parameter","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of PathItem","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","$ref","summary","description","get","put","post","delete","options","head","patch","trace","servers","parameters"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.openapi.models.PathItem.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","$ref","summary","description","get","put","post","delete","options","head","patch","trace","servers","parameters"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["fastapi.openapi.models.Server"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":["fastapi.openapi.models.Parameter","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of PathItem","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.openapi.models.PathItem.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","$ref","summary","description","get","put","post","delete","options","head","patch","trace","servers","parameters"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["fastapi.openapi.models.Server"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":["fastapi.openapi.models.Parameter","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of PathItem","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"delete":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.PathItem.delete","name":"delete","setter_type":null,"type":{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"description":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.PathItem.description","name":"description","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"get":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.PathItem.get","name":"get","setter_type":null,"type":{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"head":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.PathItem.head","name":"head","setter_type":null,"type":{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"options":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.PathItem.options","name":"options","setter_type":null,"type":{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.PathItem.parameters","name":"parameters","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":["fastapi.openapi.models.Parameter","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"patch":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.PathItem.patch","name":"patch","setter_type":null,"type":{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"post":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.PathItem.post","name":"post","setter_type":null,"type":{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"put":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.PathItem.put","name":"put","setter_type":null,"type":{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"ref":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.PathItem.ref","name":"ref","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"servers":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.PathItem.servers","name":"servers","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["fastapi.openapi.models.Server"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"summary":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.PathItem.summary","name":"summary","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"trace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.PathItem.trace","name":"trace","setter_type":null,"type":{".class":"UnionType","items":["fastapi.openapi.models.Operation",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.PathItem.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.PathItem","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Reference":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.main.BaseModel"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.Reference","name":"Reference","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.Reference","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":"$ref","column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":103,"name":"ref","type":"builtins.str"}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.Reference","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.openapi.models.Reference.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3],"arg_names":["self","$ref"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.Reference.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3],"arg_names":["self","$ref"],"arg_types":["fastapi.openapi.models.Reference","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of Reference","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","$ref"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.openapi.models.Reference.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","$ref"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of Reference","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.openapi.models.Reference.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","$ref"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of Reference","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"ref":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Reference.ref","name":"ref","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.Reference.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.Reference","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"RequestBody":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.openapi.models.BaseModelWithConfig"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.RequestBody","name":"RequestBody","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.RequestBody","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":284,"name":"description","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":285,"name":"content","type":{".class":"Instance","args":["builtins.str","fastapi.openapi.models.MediaType"],"extra_attrs":null,"type_ref":"builtins.dict"}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":286,"name":"required","type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.RequestBody","fastapi.openapi.models.BaseModelWithConfig","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.openapi.models.RequestBody.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,3,5],"arg_names":["self","description","content","required"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.RequestBody.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,3,5],"arg_names":["self","description","content","required"],"arg_types":["fastapi.openapi.models.RequestBody",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str","fastapi.openapi.models.MediaType"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of RequestBody","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","description","content","required"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.openapi.models.RequestBody.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","description","content","required"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str","fastapi.openapi.models.MediaType"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of RequestBody","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.openapi.models.RequestBody.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","description","content","required"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str","fastapi.openapi.models.MediaType"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of RequestBody","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"content":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.openapi.models.RequestBody.content","name":"content","setter_type":null,"type":{".class":"Instance","args":["builtins.str","fastapi.openapi.models.MediaType"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"description":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.RequestBody.description","name":"description","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"required":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.RequestBody.required","name":"required","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.RequestBody.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.RequestBody","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Response":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.openapi.models.BaseModelWithConfig"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.Response","name":"Response","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.Response","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":299,"name":"description","type":"builtins.str"},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":300,"name":"headers","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Header","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":301,"name":"content","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.MediaType"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":302,"name":"links","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Link","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.Response","fastapi.openapi.models.BaseModelWithConfig","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.openapi.models.Response.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,5,5,5],"arg_names":["self","description","headers","content","links"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.Response.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3,5,5,5],"arg_names":["self","description","headers","content","links"],"arg_types":["fastapi.openapi.models.Response","builtins.str",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Header","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.MediaType"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Link","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of Response","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","description","headers","content","links"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.openapi.models.Response.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","description","headers","content","links"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Header","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.MediaType"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Link","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of Response","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.openapi.models.Response.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","description","headers","content","links"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Header","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.MediaType"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Link","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of Response","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"content":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Response.content","name":"content","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.MediaType"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"description":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.openapi.models.Response.description","name":"description","setter_type":null,"type":"builtins.str"}},"headers":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Response.headers","name":"headers","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Header","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"links":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Response.links","name":"links","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["fastapi.openapi.models.Link","fastapi.openapi.models.Reference"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.Response.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.Response","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Schema":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.openapi.models.BaseModelWithConfig"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.Schema","name":"Schema","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.Schema","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":"$schema","column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":133,"name":"schema_","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":"$vocabulary","column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":134,"name":"vocabulary","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":"$id","column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":135,"name":"id","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":"$anchor","column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":136,"name":"anchor","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":"$dynamicAnchor","column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":137,"name":"dynamicAnchor","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":"$ref","column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":138,"name":"ref","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":"$dynamicRef","column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":139,"name":"dynamicRef","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":"$defs","column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":140,"name":"defs","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":"$comment","column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":141,"name":"comment","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":144,"name":"allOf","type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":145,"name":"anyOf","type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":146,"name":"oneOf","type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":"not","column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":147,"name":"not_","type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":"if","column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":148,"name":"if_","type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":149,"name":"then","type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":"else","column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":150,"name":"else_","type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":151,"name":"dependentSchemas","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":152,"name":"prefixItems","type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":156,"name":"items","type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"},{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":157,"name":"contains","type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":158,"name":"properties","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":159,"name":"patternProperties","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":160,"name":"additionalProperties","type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":161,"name":"propertyNames","type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":162,"name":"unevaluatedItems","type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":163,"name":"unevaluatedProperties","type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":166,"name":"type","type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaType"},{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaType"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":167,"name":"enum","type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":168,"name":"const","type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":169,"name":"multipleOf","type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":170,"name":"maximum","type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":171,"name":"exclusiveMaximum","type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":172,"name":"minimum","type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":173,"name":"exclusiveMinimum","type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":174,"name":"maxLength","type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":175,"name":"minLength","type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":176,"name":"pattern","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":177,"name":"maxItems","type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":178,"name":"minItems","type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":179,"name":"uniqueItems","type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":180,"name":"maxContains","type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":181,"name":"minContains","type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":182,"name":"maxProperties","type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":183,"name":"minProperties","type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":184,"name":"required","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":185,"name":"dependentRequired","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":188,"name":"format","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":191,"name":"contentEncoding","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":192,"name":"contentMediaType","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":193,"name":"contentSchema","type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":196,"name":"title","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":197,"name":"description","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":198,"name":"default","type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":199,"name":"deprecated","type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":200,"name":"readOnly","type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":201,"name":"writeOnly","type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":202,"name":"examples","type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":205,"name":"discriminator","type":{".class":"UnionType","items":["fastapi.openapi.models.Discriminator",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":206,"name":"xml","type":{".class":"UnionType","items":["fastapi.openapi.models.XML",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":207,"name":"externalDocs","type":{".class":"UnionType","items":["fastapi.openapi.models.ExternalDocumentation",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":208,"name":"example","type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false}}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.Schema","fastapi.openapi.models.BaseModelWithConfig","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.openapi.models.Schema.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","$schema","$vocabulary","$id","$anchor","$dynamicAnchor","$ref","$dynamicRef","$defs","$comment","allOf","anyOf","oneOf","not","if","then","else","dependentSchemas","prefixItems","items","contains","properties","patternProperties","additionalProperties","propertyNames","unevaluatedItems","unevaluatedProperties","type","enum","const","multipleOf","maximum","exclusiveMaximum","minimum","exclusiveMinimum","maxLength","minLength","pattern","maxItems","minItems","uniqueItems","maxContains","minContains","maxProperties","minProperties","required","dependentRequired","format","contentEncoding","contentMediaType","contentSchema","title","description","default","deprecated","readOnly","writeOnly","examples","discriminator","xml","externalDocs","example"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.Schema.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","$schema","$vocabulary","$id","$anchor","$dynamicAnchor","$ref","$dynamicRef","$defs","$comment","allOf","anyOf","oneOf","not","if","then","else","dependentSchemas","prefixItems","items","contains","properties","patternProperties","additionalProperties","propertyNames","unevaluatedItems","unevaluatedProperties","type","enum","const","multipleOf","maximum","exclusiveMaximum","minimum","exclusiveMinimum","maxLength","minLength","pattern","maxItems","minItems","uniqueItems","maxContains","minContains","maxProperties","minProperties","required","dependentRequired","format","contentEncoding","contentMediaType","contentSchema","title","description","default","deprecated","readOnly","writeOnly","examples","discriminator","xml","externalDocs","example"],"arg_types":["fastapi.openapi.models.Schema",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","builtins.bool",{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"array"},{".class":"LiteralType","fallback":"builtins.str","value":"boolean"},{".class":"LiteralType","fallback":"builtins.str","value":"integer"},{".class":"LiteralType","fallback":"builtins.str","value":"null"},{".class":"LiteralType","fallback":"builtins.str","value":"number"},{".class":"LiteralType","fallback":"builtins.str","value":"object"},{".class":"LiteralType","fallback":"builtins.str","value":"string"},{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaType"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Discriminator",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.XML",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.ExternalDocumentation",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of Schema","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","$schema","$vocabulary","$id","$anchor","$dynamicAnchor","$ref","$dynamicRef","$defs","$comment","allOf","anyOf","oneOf","not","if","then","else","dependentSchemas","prefixItems","items","contains","properties","patternProperties","additionalProperties","propertyNames","unevaluatedItems","unevaluatedProperties","type","enum","const","multipleOf","maximum","exclusiveMaximum","minimum","exclusiveMinimum","maxLength","minLength","pattern","maxItems","minItems","uniqueItems","maxContains","minContains","maxProperties","minProperties","required","dependentRequired","format","contentEncoding","contentMediaType","contentSchema","title","description","default","deprecated","readOnly","writeOnly","examples","discriminator","xml","externalDocs","example"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.openapi.models.Schema.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","$schema","$vocabulary","$id","$anchor","$dynamicAnchor","$ref","$dynamicRef","$defs","$comment","allOf","anyOf","oneOf","not","if","then","else","dependentSchemas","prefixItems","items","contains","properties","patternProperties","additionalProperties","propertyNames","unevaluatedItems","unevaluatedProperties","type","enum","const","multipleOf","maximum","exclusiveMaximum","minimum","exclusiveMinimum","maxLength","minLength","pattern","maxItems","minItems","uniqueItems","maxContains","minContains","maxProperties","minProperties","required","dependentRequired","format","contentEncoding","contentMediaType","contentSchema","title","description","default","deprecated","readOnly","writeOnly","examples","discriminator","xml","externalDocs","example"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","builtins.bool",{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"array"},{".class":"LiteralType","fallback":"builtins.str","value":"boolean"},{".class":"LiteralType","fallback":"builtins.str","value":"integer"},{".class":"LiteralType","fallback":"builtins.str","value":"null"},{".class":"LiteralType","fallback":"builtins.str","value":"number"},{".class":"LiteralType","fallback":"builtins.str","value":"object"},{".class":"LiteralType","fallback":"builtins.str","value":"string"},{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaType"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Discriminator",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.XML",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.ExternalDocumentation",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of Schema","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.openapi.models.Schema.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","$schema","$vocabulary","$id","$anchor","$dynamicAnchor","$ref","$dynamicRef","$defs","$comment","allOf","anyOf","oneOf","not","if","then","else","dependentSchemas","prefixItems","items","contains","properties","patternProperties","additionalProperties","propertyNames","unevaluatedItems","unevaluatedProperties","type","enum","const","multipleOf","maximum","exclusiveMaximum","minimum","exclusiveMinimum","maxLength","minLength","pattern","maxItems","minItems","uniqueItems","maxContains","minContains","maxProperties","minProperties","required","dependentRequired","format","contentEncoding","contentMediaType","contentSchema","title","description","default","deprecated","readOnly","writeOnly","examples","discriminator","xml","externalDocs","example"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","builtins.bool",{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"array"},{".class":"LiteralType","fallback":"builtins.str","value":"boolean"},{".class":"LiteralType","fallback":"builtins.str","value":"integer"},{".class":"LiteralType","fallback":"builtins.str","value":"null"},{".class":"LiteralType","fallback":"builtins.str","value":"number"},{".class":"LiteralType","fallback":"builtins.str","value":"object"},{".class":"LiteralType","fallback":"builtins.str","value":"string"},{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaType"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Schema","builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.Discriminator",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.XML",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.ExternalDocumentation",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of Schema","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"additionalProperties":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.additionalProperties","name":"additionalProperties","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"allOf":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.allOf","name":"allOf","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"anchor":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.anchor","name":"anchor","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"anyOf":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.anyOf","name":"anyOf","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"comment":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.comment","name":"comment","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"const":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.const","name":"const","setter_type":null,"type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"contains":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.contains","name":"contains","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"contentEncoding":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.contentEncoding","name":"contentEncoding","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"contentMediaType":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.contentMediaType","name":"contentMediaType","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"contentSchema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.contentSchema","name":"contentSchema","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"default":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.default","name":"default","setter_type":null,"type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"defs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.defs","name":"defs","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"dependentRequired":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.dependentRequired","name":"dependentRequired","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"dependentSchemas":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.dependentSchemas","name":"dependentSchemas","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"deprecated":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.deprecated","name":"deprecated","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"description":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.description","name":"description","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"discriminator":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.discriminator","name":"discriminator","setter_type":null,"type":{".class":"UnionType","items":["fastapi.openapi.models.Discriminator",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"dynamicAnchor":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.dynamicAnchor","name":"dynamicAnchor","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"dynamicRef":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.dynamicRef","name":"dynamicRef","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"else_":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.else_","name":"else_","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"enum":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.enum","name":"enum","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"example":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.example","name":"example","setter_type":null,"type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"examples":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.examples","name":"examples","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"exclusiveMaximum":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.exclusiveMaximum","name":"exclusiveMaximum","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"exclusiveMinimum":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.exclusiveMinimum","name":"exclusiveMinimum","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"externalDocs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.externalDocs","name":"externalDocs","setter_type":null,"type":{".class":"UnionType","items":["fastapi.openapi.models.ExternalDocumentation",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"format":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.format","name":"format","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"id":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.id","name":"id","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"if_":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.if_","name":"if_","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"items":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.items","name":"items","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"},{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"maxContains":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.maxContains","name":"maxContains","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"maxItems":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.maxItems","name":"maxItems","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"maxLength":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.maxLength","name":"maxLength","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"maxProperties":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.maxProperties","name":"maxProperties","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"maximum":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.maximum","name":"maximum","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"minContains":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.minContains","name":"minContains","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"minItems":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.minItems","name":"minItems","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"minLength":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.minLength","name":"minLength","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"minProperties":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.minProperties","name":"minProperties","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"minimum":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.minimum","name":"minimum","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"multipleOf":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.multipleOf","name":"multipleOf","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"not_":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.not_","name":"not_","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"oneOf":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.oneOf","name":"oneOf","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"pattern":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.pattern","name":"pattern","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"patternProperties":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.patternProperties","name":"patternProperties","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"prefixItems":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.prefixItems","name":"prefixItems","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"properties":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.properties","name":"properties","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"propertyNames":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.propertyNames","name":"propertyNames","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"readOnly":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.readOnly","name":"readOnly","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"ref":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.ref","name":"ref","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"required":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.required","name":"required","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"schema_":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.schema_","name":"schema_","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"then":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.then","name":"then","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"title":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.title","name":"title","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"type":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.type","name":"type","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaType"},{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaType"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"unevaluatedItems":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.unevaluatedItems","name":"unevaluatedItems","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"unevaluatedProperties":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.unevaluatedProperties","name":"unevaluatedProperties","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"fastapi.openapi.models.SchemaOrBool"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"uniqueItems":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.uniqueItems","name":"uniqueItems","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"vocabulary":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.vocabulary","name":"vocabulary","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"writeOnly":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.writeOnly","name":"writeOnly","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"xml":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Schema.xml","name":"xml","setter_type":null,"type":{".class":"UnionType","items":["fastapi.openapi.models.XML",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.Schema.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.Schema","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"SchemaOrBool":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"fastapi.openapi.models.SchemaOrBool","line":219,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["fastapi.openapi.models.Schema","builtins.bool"],"uses_pep604_syntax":false}}},"SchemaType":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"fastapi.openapi.models.SchemaType","line":125,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"array"},{".class":"LiteralType","fallback":"builtins.str","value":"boolean"},{".class":"LiteralType","fallback":"builtins.str","value":"integer"},{".class":"LiteralType","fallback":"builtins.str","value":"null"},{".class":"LiteralType","fallback":"builtins.str","value":"number"},{".class":"LiteralType","fallback":"builtins.str","value":"object"},{".class":"LiteralType","fallback":"builtins.str","value":"string"}],"uses_pep604_syntax":false}}},"SecurityBase":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.openapi.models.BaseModelWithConfig"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.SecurityBase","name":"SecurityBase","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.SecurityBase","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":"type","column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":345,"name":"type_","type":"fastapi.openapi.models.SecuritySchemeType"},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":346,"name":"description","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.SecurityBase","fastapi.openapi.models.BaseModelWithConfig","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.openapi.models.SecurityBase.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,5],"arg_names":["self","type","description"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.SecurityBase.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3,5],"arg_names":["self","type","description"],"arg_types":["fastapi.openapi.models.SecurityBase","fastapi.openapi.models.SecuritySchemeType",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of SecurityBase","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","type","description"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.openapi.models.SecurityBase.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","type","description"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"fastapi.openapi.models.SecuritySchemeType",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of SecurityBase","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.openapi.models.SecurityBase.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","type","description"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"fastapi.openapi.models.SecuritySchemeType",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of SecurityBase","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"description":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.SecurityBase.description","name":"description","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"type_":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.SecurityBase.type_","name":"type_","setter_type":null,"type":"fastapi.openapi.models.SecuritySchemeType"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.SecurityBase.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.SecurityBase","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"SecurityScheme":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"fastapi.openapi.models.SecurityScheme","line":412,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["fastapi.openapi.models.APIKey","fastapi.openapi.models.HTTPBase","fastapi.openapi.models.OAuth2","fastapi.openapi.models.OpenIdConnect","fastapi.openapi.models.HTTPBearer"],"uses_pep604_syntax":false}}},"SecuritySchemeType":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["enum.Enum"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.SecuritySchemeType","name":"SecuritySchemeType","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_enum"],"fullname":"fastapi.openapi.models.SecuritySchemeType","has_param_spec_type":false,"metaclass_type":"enum.EnumMeta","metadata":{},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.SecuritySchemeType","enum.Enum","builtins.object"],"names":{".class":"SymbolTable","apiKey":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"fastapi.openapi.models.SecuritySchemeType.apiKey","name":"apiKey","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.str","value":"apiKey"},"type_ref":"builtins.str"}}},"http":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"fastapi.openapi.models.SecuritySchemeType.http","name":"http","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.str","value":"http"},"type_ref":"builtins.str"}}},"oauth2":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"fastapi.openapi.models.SecuritySchemeType.oauth2","name":"oauth2","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.str","value":"oauth2"},"type_ref":"builtins.str"}}},"openIdConnect":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"fastapi.openapi.models.SecuritySchemeType.openIdConnect","name":"openIdConnect","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.str","value":"openIdConnect"},"type_ref":"builtins.str"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.SecuritySchemeType.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.SecuritySchemeType","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Server":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.openapi.models.BaseModelWithConfig"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.Server","name":"Server","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.Server","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":97,"name":"url","type":{".class":"UnionType","items":["pydantic.networks.AnyUrl","builtins.str"],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":98,"name":"description","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":99,"name":"variables","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.ServerVariable"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.Server","fastapi.openapi.models.BaseModelWithConfig","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.openapi.models.Server.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,5,5],"arg_names":["self","url","description","variables"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.Server.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3,5,5],"arg_names":["self","url","description","variables"],"arg_types":["fastapi.openapi.models.Server",{".class":"UnionType","items":["pydantic.networks.AnyUrl","builtins.str"],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.ServerVariable"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of Server","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","url","description","variables"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.openapi.models.Server.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","url","description","variables"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["pydantic.networks.AnyUrl","builtins.str"],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.ServerVariable"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of Server","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.openapi.models.Server.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","url","description","variables"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["pydantic.networks.AnyUrl","builtins.str"],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.ServerVariable"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of Server","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"description":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Server.description","name":"description","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"url":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.openapi.models.Server.url","name":"url","setter_type":null,"type":{".class":"UnionType","items":["pydantic.networks.AnyUrl","builtins.str"],"uses_pep604_syntax":false}}},"variables":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Server.variables","name":"variables","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","fastapi.openapi.models.ServerVariable"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.Server.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.Server","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ServerVariable":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.openapi.models.BaseModelWithConfig"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.ServerVariable","name":"ServerVariable","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.ServerVariable","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":91,"name":"enum","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":92,"name":"default","type":"builtins.str"},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":93,"name":"description","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.ServerVariable","fastapi.openapi.models.BaseModelWithConfig","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.openapi.models.ServerVariable.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,3,5],"arg_names":["self","enum","default","description"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.ServerVariable.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,3,5],"arg_names":["self","enum","default","description"],"arg_types":["fastapi.openapi.models.ServerVariable",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of ServerVariable","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","enum","default","description"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.openapi.models.ServerVariable.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","enum","default","description"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of ServerVariable","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.openapi.models.ServerVariable.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","enum","default","description"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of ServerVariable","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"default":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.openapi.models.ServerVariable.default","name":"default","setter_type":null,"type":"builtins.str"}},"description":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.ServerVariable.description","name":"description","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"enum":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.ServerVariable.enum","name":"enum","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.ServerVariable.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.ServerVariable","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Set":{".class":"SymbolTableNode","cross_ref":"typing.Set","kind":"Gdef"},"Tag":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.openapi.models.BaseModelWithConfig"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.Tag","name":"Tag","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.Tag","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":430,"name":"name","type":"builtins.str"},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":431,"name":"description","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":432,"name":"externalDocs","type":{".class":"UnionType","items":["fastapi.openapi.models.ExternalDocumentation",{".class":"NoneType"}],"uses_pep604_syntax":false}}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.Tag","fastapi.openapi.models.BaseModelWithConfig","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.openapi.models.Tag.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,5,5],"arg_names":["self","name","description","externalDocs"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.Tag.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3,5,5],"arg_names":["self","name","description","externalDocs"],"arg_types":["fastapi.openapi.models.Tag","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.ExternalDocumentation",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of Tag","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","name","description","externalDocs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.openapi.models.Tag.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","name","description","externalDocs"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.ExternalDocumentation",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of Tag","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.openapi.models.Tag.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","name","description","externalDocs"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["fastapi.openapi.models.ExternalDocumentation",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of Tag","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"description":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Tag.description","name":"description","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"externalDocs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.Tag.externalDocs","name":"externalDocs","setter_type":null,"type":{".class":"UnionType","items":["fastapi.openapi.models.ExternalDocumentation",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"name":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.openapi.models.Tag.name","name":"name","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.Tag.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.Tag","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Type":{".class":"SymbolTableNode","cross_ref":"typing.Type","kind":"Gdef"},"TypedDict":{".class":"SymbolTableNode","cross_ref":"typing.TypedDict","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"XML":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.openapi.models.BaseModelWithConfig"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.openapi.models.XML","name":"XML","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.XML","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":112,"name":"name","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":113,"name":"namespace","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":114,"name":"prefix","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":115,"name":"attribute","type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":116,"name":"wrapped","type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.openapi.models","mro":["fastapi.openapi.models.XML","fastapi.openapi.models.BaseModelWithConfig","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.openapi.models.XML.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5,5],"arg_names":["self","name","namespace","prefix","attribute","wrapped"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.models.XML.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5,5],"arg_names":["self","name","namespace","prefix","attribute","wrapped"],"arg_types":["fastapi.openapi.models.XML",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of XML","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","name","namespace","prefix","attribute","wrapped"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.openapi.models.XML.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","name","namespace","prefix","attribute","wrapped"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of XML","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.openapi.models.XML.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","name","namespace","prefix","attribute","wrapped"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of XML","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"attribute":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.XML.attribute","name":"attribute","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"name":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.XML.name","name":"name","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"namespace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.XML.namespace","name":"namespace","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"prefix":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.XML.prefix","name":"prefix","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"wrapped":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"fastapi.openapi.models.XML.wrapped","name":"wrapped","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.openapi.models.XML.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.openapi.models.XML","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.openapi.models.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.openapi.models.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.openapi.models.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.openapi.models.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.openapi.models.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.openapi.models.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_model_rebuild":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main._model_rebuild","kind":"Gdef"},"email_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"fastapi.openapi.models.email_validator","name":"email_validator","setter_type":null,"type":{".class":"AnyType","missing_import_name":"fastapi.openapi.models.email_validator","source_any":null,"type_of_any":3}}},"logger":{".class":"SymbolTableNode","cross_ref":"fastapi.logger.logger","kind":"Gdef"},"typing_deprecated":{".class":"SymbolTableNode","cross_ref":"typing_extensions.deprecated","kind":"Gdef"},"with_info_plain_validator_function":{".class":"SymbolTableNode","cross_ref":"pydantic_core.core_schema.with_info_plain_validator_function","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/openapi/models.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/openapi/models.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/openapi/models.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..9071bea5ccd141c8dc79cd4477ce240174e744e7 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/openapi/models.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[4,12,1,2,13,14,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,18],"dep_prios":[5,5,5,5,5,5,5,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,10],"dependencies":["fastapi._compat","fastapi.logger","enum","typing","pydantic","typing_extensions","builtins","_frozen_importlib","abc","annotated_types","fastapi._compat.main","fastapi._compat.shared","pydantic._internal","pydantic._internal._generate_schema","pydantic._internal._model_construction","pydantic._internal._repr","pydantic.aliases","pydantic.config","pydantic.fields","pydantic.main","pydantic.networks","pydantic.types","re"],"hash":"068d7d6b933d2792aa9f31ff2cdad94732aab57f","id":"fastapi.openapi.models","ignore_all":true,"interface_hash":"d2e6a33c271a2c6f33b750725708213c1c51c16a","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/openapi/models.py","plugin_data":null,"size":15625,"suppressed":["email_validator"],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/openapi/utils.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/openapi/utils.data.json new file mode 100644 index 0000000000000000000000000000000000000000..4271b43f929544c2417efdb80079ceeb83d71612 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/openapi/utils.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"fastapi.openapi.utils","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseModel":{".class":"SymbolTableNode","cross_ref":"pydantic.main.BaseModel","kind":"Gdef"},"BaseRoute":{".class":"SymbolTableNode","cross_ref":"starlette.routing.BaseRoute","kind":"Gdef"},"Body":{".class":"SymbolTableNode","cross_ref":"fastapi.params.Body","kind":"Gdef"},"DefaultPlaceholder":{".class":"SymbolTableNode","cross_ref":"fastapi.datastructures.DefaultPlaceholder","kind":"Gdef"},"Dependant":{".class":"SymbolTableNode","cross_ref":"fastapi.dependencies.models.Dependant","kind":"Gdef"},"Dict":{".class":"SymbolTableNode","cross_ref":"typing.Dict","kind":"Gdef"},"JSONResponse":{".class":"SymbolTableNode","cross_ref":"starlette.responses.JSONResponse","kind":"Gdef"},"JsonSchemaValue":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.v1.JsonSchemaValue","kind":"Gdef"},"List":{".class":"SymbolTableNode","cross_ref":"typing.List","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Literal","kind":"Gdef"},"METHODS_WITH_BODY":{".class":"SymbolTableNode","cross_ref":"fastapi.openapi.constants.METHODS_WITH_BODY","kind":"Gdef"},"ModelField":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.model_field.ModelField","kind":"Gdef"},"ModelNameMap":{".class":"SymbolTableNode","cross_ref":"fastapi.types.ModelNameMap","kind":"Gdef"},"OpenAPI":{".class":"SymbolTableNode","cross_ref":"fastapi.openapi.models.OpenAPI","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"ParamTypes":{".class":"SymbolTableNode","cross_ref":"fastapi.params.ParamTypes","kind":"Gdef"},"REF_PREFIX":{".class":"SymbolTableNode","cross_ref":"fastapi.openapi.constants.REF_PREFIX","kind":"Gdef"},"Response":{".class":"SymbolTableNode","cross_ref":"starlette.responses.Response","kind":"Gdef"},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef"},"Set":{".class":"SymbolTableNode","cross_ref":"typing.Set","kind":"Gdef"},"Tuple":{".class":"SymbolTableNode","cross_ref":"typing.Tuple","kind":"Gdef"},"Type":{".class":"SymbolTableNode","cross_ref":"typing.Type","kind":"Gdef"},"Undefined":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.v2.Undefined","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.openapi.utils.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.openapi.utils.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.openapi.utils.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.openapi.utils.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.openapi.utils.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.openapi.utils.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_get_flat_fields_from_params":{".class":"SymbolTableNode","cross_ref":"fastapi.dependencies.utils._get_flat_fields_from_params","kind":"Gdef"},"_get_openapi_operation_parameters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3,3,5],"arg_names":["dependant","model_name_map","field_mapping","separate_input_output_schemas"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.utils._get_openapi_operation_parameters","name":"_get_openapi_operation_parameters","original_first_arg":"dependant","type":{".class":"CallableType","arg_kinds":[3,3,3,5],"arg_names":["dependant","model_name_map","field_mapping","separate_input_output_schemas"],"arg_types":["fastapi.dependencies.models.Dependant",{".class":"TypeAliasType","args":[],"type_ref":"fastapi.types.ModelNameMap"},{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["fastapi._compat.model_field.ModelField",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"validation"},{".class":"LiteralType","fallback":"builtins.str","value":"serialization"}],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TypeAliasType","args":[],"type_ref":"fastapi._compat.v1.JsonSchemaValue"}],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_openapi_operation_parameters","ret_type":{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_is_model_field":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main._is_model_field","kind":"Gdef"},"cast":{".class":"SymbolTableNode","cross_ref":"typing.cast","kind":"Gdef"},"deep_dict_update":{".class":"SymbolTableNode","cross_ref":"fastapi.utils.deep_dict_update","kind":"Gdef"},"generate_operation_id":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3],"arg_names":["route","method"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.utils.generate_operation_id","name":"generate_operation_id","original_first_arg":"route","type":{".class":"CallableType","arg_kinds":[3,3],"arg_names":["route","method"],"arg_types":["fastapi.routing.APIRoute","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"generate_operation_id","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"generate_operation_id_for_path":{".class":"SymbolTableNode","cross_ref":"fastapi.utils.generate_operation_id_for_path","kind":"Gdef"},"generate_operation_summary":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3],"arg_names":["route","method"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.utils.generate_operation_summary","name":"generate_operation_summary","original_first_arg":"route","type":{".class":"CallableType","arg_kinds":[3,3],"arg_names":["route","method"],"arg_types":["fastapi.routing.APIRoute","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"generate_operation_summary","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_compat_model_name_map":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main.get_compat_model_name_map","kind":"Gdef"},"get_definitions":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main.get_definitions","kind":"Gdef"},"get_fields_from_routes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["routes"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.utils.get_fields_from_routes","name":"get_fields_from_routes","original_first_arg":"routes","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["routes"],"arg_types":[{".class":"Instance","args":["starlette.routing.BaseRoute"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_fields_from_routes","ret_type":{".class":"Instance","args":["fastapi._compat.model_field.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_flat_dependant":{".class":"SymbolTableNode","cross_ref":"fastapi.dependencies.utils.get_flat_dependant","kind":"Gdef"},"get_flat_params":{".class":"SymbolTableNode","cross_ref":"fastapi.dependencies.utils.get_flat_params","kind":"Gdef"},"get_openapi":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3,5,5,5,3,5,5,5,5,5,5,5,5],"arg_names":["title","version","openapi_version","summary","description","routes","webhooks","tags","servers","terms_of_service","contact","license_info","separate_input_output_schemas","external_docs"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.utils.get_openapi","name":"get_openapi","original_first_arg":"title","type":{".class":"CallableType","arg_kinds":[3,3,5,5,5,3,5,5,5,5,5,5,5,5],"arg_names":["title","version","openapi_version","summary","description","routes","webhooks","tags","servers","terms_of_service","contact","license_info","separate_input_output_schemas","external_docs"],"arg_types":["builtins.str","builtins.str","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["starlette.routing.BaseRoute"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"Instance","args":["starlette.routing.BaseRoute"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_openapi","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_openapi_operation_metadata":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3,3],"arg_names":["route","method","operation_ids"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.utils.get_openapi_operation_metadata","name":"get_openapi_operation_metadata","original_first_arg":"route","type":{".class":"CallableType","arg_kinds":[3,3,3],"arg_names":["route","method","operation_ids"],"arg_types":["fastapi.routing.APIRoute","builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_openapi_operation_metadata","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_openapi_operation_request_body":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3,3,5],"arg_names":["body_field","model_name_map","field_mapping","separate_input_output_schemas"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.utils.get_openapi_operation_request_body","name":"get_openapi_operation_request_body","original_first_arg":"body_field","type":{".class":"CallableType","arg_kinds":[3,3,3,5],"arg_names":["body_field","model_name_map","field_mapping","separate_input_output_schemas"],"arg_types":[{".class":"UnionType","items":["fastapi._compat.model_field.ModelField",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"TypeAliasType","args":[],"type_ref":"fastapi.types.ModelNameMap"},{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["fastapi._compat.model_field.ModelField",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"validation"},{".class":"LiteralType","fallback":"builtins.str","value":"serialization"}],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TypeAliasType","args":[],"type_ref":"fastapi._compat.v1.JsonSchemaValue"}],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_openapi_operation_request_body","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_openapi_path":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3,3,3,5],"arg_names":["route","operation_ids","model_name_map","field_mapping","separate_input_output_schemas"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.utils.get_openapi_path","name":"get_openapi_path","original_first_arg":"route","type":{".class":"CallableType","arg_kinds":[3,3,3,3,5],"arg_names":["route","operation_ids","model_name_map","field_mapping","separate_input_output_schemas"],"arg_types":["fastapi.routing.APIRoute",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"TypeAliasType","args":[],"type_ref":"fastapi.types.ModelNameMap"},{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["fastapi._compat.model_field.ModelField",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"validation"},{".class":"LiteralType","fallback":"builtins.str","value":"serialization"}],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TypeAliasType","args":[],"type_ref":"fastapi._compat.v1.JsonSchemaValue"}],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_openapi_path","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_openapi_security_definitions":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["flat_dependant"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.openapi.utils.get_openapi_security_definitions","name":"get_openapi_security_definitions","original_first_arg":"flat_dependant","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["flat_dependant"],"arg_types":["fastapi.dependencies.models.Dependant"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_openapi_security_definitions","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"extra_attrs":null,"type_ref":"builtins.list"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_schema_from_model_field":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.main.get_schema_from_model_field","kind":"Gdef"},"http":{".class":"SymbolTableNode","cross_ref":"http","kind":"Gdef"},"inspect":{".class":"SymbolTableNode","cross_ref":"inspect","kind":"Gdef"},"is_body_allowed_for_status_code":{".class":"SymbolTableNode","cross_ref":"fastapi.utils.is_body_allowed_for_status_code","kind":"Gdef"},"jsonable_encoder":{".class":"SymbolTableNode","cross_ref":"fastapi.encoders.jsonable_encoder","kind":"Gdef"},"lenient_issubclass":{".class":"SymbolTableNode","cross_ref":"fastapi._compat.shared.lenient_issubclass","kind":"Gdef"},"routing":{".class":"SymbolTableNode","cross_ref":"fastapi.routing","kind":"Gdef"},"status_code_ranges":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"fastapi.openapi.utils.status_code_ranges","name":"status_code_ranges","setter_type":null,"type":{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"validation_error_definition":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"fastapi.openapi.utils.validation_error_definition","name":"validation_error_definition","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Collection"}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"validation_error_response_definition":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"fastapi.openapi.utils.validation_error_response_definition","name":"validation_error_response_definition","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Collection"}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"warnings":{".class":"SymbolTableNode","cross_ref":"warnings","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/openapi/utils.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/openapi/utils.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/openapi/utils.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..f9258089be60b099ff810611fc34b9a4c07be7b1 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/openapi/utils.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106718,"dep_lines":[17,18,24,25,1,6,7,16,23,26,27,28,29,35,36,1,2,3,4,6,34,37,1,1,1,1,1,1,1,1,1,1],"dep_prios":[5,5,5,5,10,10,5,5,5,5,5,5,5,5,5,20,10,10,5,20,5,5,5,30,30,30,30,30,30,30,30,30],"dependencies":["fastapi.dependencies.models","fastapi.dependencies.utils","fastapi.openapi.constants","fastapi.openapi.models","http.client","fastapi.routing","fastapi._compat","fastapi.datastructures","fastapi.encoders","fastapi.params","fastapi.responses","fastapi.types","fastapi.utils","starlette.responses","starlette.routing","http","inspect","warnings","typing","fastapi","pydantic","typing_extensions","builtins","_frozen_importlib","abc","enum","fastapi._compat.model_field","fastapi.dependencies","pydantic._internal","pydantic._internal._model_construction","pydantic.main","starlette"],"hash":"895238a7c2ba61b4f1d048b866c69bf467cd033b","id":"fastapi.openapi.utils","ignore_all":true,"interface_hash":"66d4e06d0b0a88b6a87bca03a3d935db229eeff8","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/openapi/utils.py","plugin_data":null,"size":23255,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..d400ff9cbbf20a72584d430460c9baa1b29841a3 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"fastapi.security","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","APIKeyCookie":{".class":"SymbolTableNode","cross_ref":"fastapi.security.api_key.APIKeyCookie","kind":"Gdef"},"APIKeyHeader":{".class":"SymbolTableNode","cross_ref":"fastapi.security.api_key.APIKeyHeader","kind":"Gdef"},"APIKeyQuery":{".class":"SymbolTableNode","cross_ref":"fastapi.security.api_key.APIKeyQuery","kind":"Gdef"},"HTTPAuthorizationCredentials":{".class":"SymbolTableNode","cross_ref":"fastapi.security.http.HTTPAuthorizationCredentials","kind":"Gdef"},"HTTPBasic":{".class":"SymbolTableNode","cross_ref":"fastapi.security.http.HTTPBasic","kind":"Gdef"},"HTTPBasicCredentials":{".class":"SymbolTableNode","cross_ref":"fastapi.security.http.HTTPBasicCredentials","kind":"Gdef"},"HTTPBearer":{".class":"SymbolTableNode","cross_ref":"fastapi.security.http.HTTPBearer","kind":"Gdef"},"HTTPDigest":{".class":"SymbolTableNode","cross_ref":"fastapi.security.http.HTTPDigest","kind":"Gdef"},"OAuth2":{".class":"SymbolTableNode","cross_ref":"fastapi.security.oauth2.OAuth2","kind":"Gdef"},"OAuth2AuthorizationCodeBearer":{".class":"SymbolTableNode","cross_ref":"fastapi.security.oauth2.OAuth2AuthorizationCodeBearer","kind":"Gdef"},"OAuth2PasswordBearer":{".class":"SymbolTableNode","cross_ref":"fastapi.security.oauth2.OAuth2PasswordBearer","kind":"Gdef"},"OAuth2PasswordRequestForm":{".class":"SymbolTableNode","cross_ref":"fastapi.security.oauth2.OAuth2PasswordRequestForm","kind":"Gdef"},"OAuth2PasswordRequestFormStrict":{".class":"SymbolTableNode","cross_ref":"fastapi.security.oauth2.OAuth2PasswordRequestFormStrict","kind":"Gdef"},"OpenIdConnect":{".class":"SymbolTableNode","cross_ref":"fastapi.security.open_id_connect_url.OpenIdConnect","kind":"Gdef"},"SecurityScopes":{".class":"SymbolTableNode","cross_ref":"fastapi.security.oauth2.SecurityScopes","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/security/__init__.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..48d13175bba33163e349255fae22ba285c874f05 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106718,"dep_lines":[1,4,9,15,1,1,1,1],"dep_prios":[5,5,5,5,5,30,30,30],"dependencies":["fastapi.security.api_key","fastapi.security.http","fastapi.security.oauth2","fastapi.security.open_id_connect_url","builtins","_frozen_importlib","abc","typing"],"hash":"1c6e5e5c624635e55ff82959021992534c31b688","id":"fastapi.security","ignore_all":true,"interface_hash":"11f1a13853068baada14a7369c0ee5fff1551e85","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/security/__init__.py","plugin_data":null,"size":881,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/api_key.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/api_key.data.json new file mode 100644 index 0000000000000000000000000000000000000000..f35634a741fabfc28bdef0d7eb46a54a6a11e675 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/api_key.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"fastapi.security.api_key","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","APIKey":{".class":"SymbolTableNode","cross_ref":"fastapi.openapi.models.APIKey","kind":"Gdef"},"APIKeyBase":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.security.base.SecurityBase"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.security.api_key.APIKeyBase","name":"APIKeyBase","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.security.api_key.APIKeyBase","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"fastapi.security.api_key","mro":["fastapi.security.api_key.APIKeyBase","fastapi.security.base.SecurityBase","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0,0],"arg_names":["self","location","name","description","scheme_name","auto_error"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"fastapi.security.api_key.APIKeyBase.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0],"arg_names":["self","location","name","description","scheme_name","auto_error"],"arg_types":["fastapi.security.api_key.APIKeyBase","fastapi.openapi.models.APIKeyIn","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of APIKeyBase","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"auto_error":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"fastapi.security.api_key.APIKeyBase.auto_error","name":"auto_error","setter_type":null,"type":"builtins.bool"}},"check_api_key":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"fastapi.security.api_key.APIKeyBase.check_api_key","name":"check_api_key","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","api_key"],"arg_types":["fastapi.security.api_key.APIKeyBase",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"check_api_key of APIKeyBase","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"make_not_authenticated_error":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"fastapi.security.api_key.APIKeyBase.make_not_authenticated_error","name":"make_not_authenticated_error","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi.security.api_key.APIKeyBase"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"make_not_authenticated_error of APIKeyBase","ret_type":"starlette.exceptions.HTTPException","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"model":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"fastapi.security.api_key.APIKeyBase.model","name":"model","setter_type":null,"type":"fastapi.openapi.models.APIKey"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.security.api_key.APIKeyBase.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.security.api_key.APIKeyBase","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"APIKeyCookie":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.security.api_key.APIKeyBase"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.security.api_key.APIKeyCookie","name":"APIKeyCookie","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.security.api_key.APIKeyCookie","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"fastapi.security.api_key","mro":["fastapi.security.api_key.APIKeyCookie","fastapi.security.api_key.APIKeyBase","fastapi.security.base.SecurityBase","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"fastapi.security.api_key.APIKeyCookie.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["fastapi.security.api_key.APIKeyCookie","starlette.requests.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of APIKeyCookie","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,5,5,5],"arg_names":["self","name","scheme_name","description","auto_error"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"fastapi.security.api_key.APIKeyCookie.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3,5,5,5],"arg_names":["self","name","scheme_name","description","auto_error"],"arg_types":["fastapi.security.api_key.APIKeyCookie","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of APIKeyCookie","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.security.api_key.APIKeyCookie.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.security.api_key.APIKeyCookie","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"APIKeyHeader":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.security.api_key.APIKeyBase"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.security.api_key.APIKeyHeader","name":"APIKeyHeader","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.security.api_key.APIKeyHeader","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"fastapi.security.api_key","mro":["fastapi.security.api_key.APIKeyHeader","fastapi.security.api_key.APIKeyBase","fastapi.security.base.SecurityBase","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"fastapi.security.api_key.APIKeyHeader.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["fastapi.security.api_key.APIKeyHeader","starlette.requests.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of APIKeyHeader","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,5,5,5],"arg_names":["self","name","scheme_name","description","auto_error"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"fastapi.security.api_key.APIKeyHeader.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3,5,5,5],"arg_names":["self","name","scheme_name","description","auto_error"],"arg_types":["fastapi.security.api_key.APIKeyHeader","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of APIKeyHeader","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.security.api_key.APIKeyHeader.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.security.api_key.APIKeyHeader","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"APIKeyIn":{".class":"SymbolTableNode","cross_ref":"fastapi.openapi.models.APIKeyIn","kind":"Gdef"},"APIKeyQuery":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.security.api_key.APIKeyBase"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.security.api_key.APIKeyQuery","name":"APIKeyQuery","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.security.api_key.APIKeyQuery","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"fastapi.security.api_key","mro":["fastapi.security.api_key.APIKeyQuery","fastapi.security.api_key.APIKeyBase","fastapi.security.base.SecurityBase","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"fastapi.security.api_key.APIKeyQuery.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["fastapi.security.api_key.APIKeyQuery","starlette.requests.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of APIKeyQuery","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,5,5,5],"arg_names":["self","name","scheme_name","description","auto_error"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"fastapi.security.api_key.APIKeyQuery.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3,5,5,5],"arg_names":["self","name","scheme_name","description","auto_error"],"arg_types":["fastapi.security.api_key.APIKeyQuery","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of APIKeyQuery","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.security.api_key.APIKeyQuery.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.security.api_key.APIKeyQuery","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Annotated":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Annotated","kind":"Gdef"},"Doc":{".class":"SymbolTableNode","cross_ref":"annotated_doc.main.Doc","kind":"Gdef"},"HTTPException":{".class":"SymbolTableNode","cross_ref":"starlette.exceptions.HTTPException","kind":"Gdef"},"HTTP_401_UNAUTHORIZED":{".class":"SymbolTableNode","cross_ref":"starlette.status.HTTP_401_UNAUTHORIZED","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"Request":{".class":"SymbolTableNode","cross_ref":"starlette.requests.Request","kind":"Gdef"},"SecurityBase":{".class":"SymbolTableNode","cross_ref":"fastapi.security.base.SecurityBase","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.api_key.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.api_key.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.api_key.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.api_key.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.api_key.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.api_key.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/security/api_key.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/api_key.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/api_key.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..cc472a06d5becee010097f3a860458e2ab094819 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/api_key.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106718,"dep_lines":[4,5,6,7,8,1,3,9,1,1,1,1,1,1,1,1,1,1],"dep_prios":[5,5,5,5,5,5,5,5,5,30,30,30,30,30,30,30,30,30],"dependencies":["fastapi.openapi.models","fastapi.security.base","starlette.exceptions","starlette.requests","starlette.status","typing","annotated_doc","typing_extensions","builtins","_frozen_importlib","abc","enum","fastapi.openapi","pydantic","pydantic._internal","pydantic._internal._model_construction","pydantic.main","starlette"],"hash":"d8cdbe3fef1161b44cce8ac3e3c33a0a85959499","id":"fastapi.security.api_key","ignore_all":true,"interface_hash":"815f5915559f69ca3c523c34ce5b3c93dc10603e","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/security/api_key.py","plugin_data":null,"size":9828,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/base.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/base.data.json new file mode 100644 index 0000000000000000000000000000000000000000..55c4ad1ec35159a8b3943e4889612307c0c10033 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/base.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"fastapi.security.base","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","SecurityBase":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.security.base.SecurityBase","name":"SecurityBase","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.security.base.SecurityBase","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"fastapi.security.base","mro":["fastapi.security.base.SecurityBase","builtins.object"],"names":{".class":"SymbolTable","model":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.security.base.SecurityBase.model","name":"model","setter_type":null,"type":"fastapi.openapi.models.SecurityBase"}},"scheme_name":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.security.base.SecurityBase.scheme_name","name":"scheme_name","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.security.base.SecurityBase.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.security.base.SecurityBase","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"SecurityBaseModel":{".class":"SymbolTableNode","cross_ref":"fastapi.openapi.models.SecurityBase","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.base.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.base.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.base.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.base.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.base.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.base.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/security/base.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/base.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/base.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..e40e1c473f0307644b1bfeec381bda109a2d5e12 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/base.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,1,1,1,1,1,1,1,1,1],"dep_prios":[5,5,30,30,30,30,30,30,30,30],"dependencies":["fastapi.openapi.models","builtins","_frozen_importlib","abc","fastapi.openapi","pydantic","pydantic._internal","pydantic._internal._model_construction","pydantic.main","typing"],"hash":"55d62e72d80b64988f1e310fbc9d066960961a33","id":"fastapi.security.base","ignore_all":true,"interface_hash":"184aca64ee4b40aeafe4a66f788e623d0f829c7a","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/security/base.py","plugin_data":null,"size":141,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/http.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/http.data.json new file mode 100644 index 0000000000000000000000000000000000000000..2e2ca8fcfe4ef7cbe17cbbb17ca97b4bdb8898ce --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/http.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"fastapi.security.http","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Annotated":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Annotated","kind":"Gdef"},"BaseModel":{".class":"SymbolTableNode","cross_ref":"pydantic.main.BaseModel","kind":"Gdef"},"Dict":{".class":"SymbolTableNode","cross_ref":"typing.Dict","kind":"Gdef"},"Doc":{".class":"SymbolTableNode","cross_ref":"annotated_doc.main.Doc","kind":"Gdef"},"HTTPAuthorizationCredentials":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.main.BaseModel"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.security.http.HTTPAuthorizationCredentials","name":"HTTPAuthorizationCredentials","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.security.http.HTTPAuthorizationCredentials","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":52,"name":"scheme","type":"builtins.str"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":60,"name":"credentials","type":"builtins.str"}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.security.http","mro":["fastapi.security.http.HTTPAuthorizationCredentials","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.security.http.HTTPAuthorizationCredentials.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,3],"arg_names":["self","scheme","credentials"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.security.http.HTTPAuthorizationCredentials.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3,3],"arg_names":["self","scheme","credentials"],"arg_types":["fastapi.security.http.HTTPAuthorizationCredentials","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of HTTPAuthorizationCredentials","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","scheme","credentials"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.security.http.HTTPAuthorizationCredentials.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","scheme","credentials"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of HTTPAuthorizationCredentials","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.security.http.HTTPAuthorizationCredentials.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","scheme","credentials"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of HTTPAuthorizationCredentials","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"credentials":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.security.http.HTTPAuthorizationCredentials.credentials","name":"credentials","setter_type":null,"type":"builtins.str"}},"scheme":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.security.http.HTTPAuthorizationCredentials.scheme","name":"scheme","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.security.http.HTTPAuthorizationCredentials.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.security.http.HTTPAuthorizationCredentials","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"HTTPBase":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.security.base.SecurityBase"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.security.http.HTTPBase","name":"HTTPBase","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.security.http.HTTPBase","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"fastapi.security.http","mro":["fastapi.security.http.HTTPBase","fastapi.security.base.SecurityBase","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"fastapi.security.http.HTTPBase.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["fastapi.security.http.HTTPBase","starlette.requests.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of HTTPBase","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"UnionType","items":["fastapi.security.http.HTTPAuthorizationCredentials",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,5,5,5],"arg_names":["self","scheme","scheme_name","description","auto_error"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"fastapi.security.http.HTTPBase.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3,5,5,5],"arg_names":["self","scheme","scheme_name","description","auto_error"],"arg_types":["fastapi.security.http.HTTPBase","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of HTTPBase","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"auto_error":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"fastapi.security.http.HTTPBase.auto_error","name":"auto_error","setter_type":null,"type":"builtins.bool"}},"make_authenticate_headers":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"fastapi.security.http.HTTPBase.make_authenticate_headers","name":"make_authenticate_headers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi.security.http.HTTPBase"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"make_authenticate_headers of HTTPBase","ret_type":{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"make_not_authenticated_error":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"fastapi.security.http.HTTPBase.make_not_authenticated_error","name":"make_not_authenticated_error","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi.security.http.HTTPBase"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"make_not_authenticated_error of HTTPBase","ret_type":"fastapi.exceptions.HTTPException","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"model":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"fastapi.security.http.HTTPBase.model","name":"model","setter_type":null,"type":"fastapi.openapi.models.HTTPBase"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.security.http.HTTPBase.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.security.http.HTTPBase","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"HTTPBaseModel":{".class":"SymbolTableNode","cross_ref":"fastapi.openapi.models.HTTPBase","kind":"Gdef"},"HTTPBasic":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.security.http.HTTPBase"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.security.http.HTTPBasic","name":"HTTPBasic","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.security.http.HTTPBasic","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"fastapi.security.http","mro":["fastapi.security.http.HTTPBasic","fastapi.security.http.HTTPBase","fastapi.security.base.SecurityBase","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"fastapi.security.http.HTTPBasic.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["fastapi.security.http.HTTPBasic","starlette.requests.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of HTTPBasic","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"UnionType","items":["fastapi.security.http.HTTPBasicCredentials",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5],"arg_names":["self","scheme_name","realm","description","auto_error"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"fastapi.security.http.HTTPBasic.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":["self","scheme_name","realm","description","auto_error"],"arg_types":["fastapi.security.http.HTTPBasic",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of HTTPBasic","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"make_authenticate_headers":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"fastapi.security.http.HTTPBasic.make_authenticate_headers","name":"make_authenticate_headers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi.security.http.HTTPBasic"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"make_authenticate_headers of HTTPBasic","ret_type":{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"realm":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"fastapi.security.http.HTTPBasic.realm","name":"realm","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.security.http.HTTPBasic.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.security.http.HTTPBasic","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"HTTPBasicCredentials":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.main.BaseModel"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.security.http.HTTPBasicCredentials","name":"HTTPBasicCredentials","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.security.http.HTTPBasicCredentials","has_param_spec_type":false,"metaclass_type":"pydantic._internal._model_construction.ModelMetaclass","metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":211,"name":"__pydantic_extra__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":214,"name":"__pydantic_fields_set__","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":true,"kw_only":true,"line":217,"name":"__pydantic_private__","type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":26,"name":"username","type":"builtins.str"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":true,"line":27,"name":"password","type":"builtins.str"}],"frozen":false},"dataclass_tag":{}},"module_name":"fastapi.security.http","mro":["fastapi.security.http.HTTPBasicCredentials","pydantic.main.BaseModel","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"fastapi.security.http.HTTPBasicCredentials.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,3],"arg_names":["self","username","password"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.security.http.HTTPBasicCredentials.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3,3],"arg_names":["self","username","password"],"arg_types":["fastapi.security.http.HTTPBasicCredentials","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of HTTPBasicCredentials","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","username","password"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"fastapi.security.http.HTTPBasicCredentials.__mypy-replace","name":"__mypy-replace","original_first_arg":"__pydantic_extra__","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","username","password"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of HTTPBasicCredentials","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"fastapi.security.http.HTTPBasicCredentials.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5],"arg_names":["__pydantic_extra__","__pydantic_fields_set__","__pydantic_private__","username","password"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of HTTPBasicCredentials","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"password":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.security.http.HTTPBasicCredentials.password","name":"password","setter_type":null,"type":"builtins.str"}},"username":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"fastapi.security.http.HTTPBasicCredentials.username","name":"username","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.security.http.HTTPBasicCredentials.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.security.http.HTTPBasicCredentials","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"HTTPBearer":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.security.http.HTTPBase"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.security.http.HTTPBearer","name":"HTTPBearer","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.security.http.HTTPBearer","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"fastapi.security.http","mro":["fastapi.security.http.HTTPBearer","fastapi.security.http.HTTPBase","fastapi.security.base.SecurityBase","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"fastapi.security.http.HTTPBearer.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["fastapi.security.http.HTTPBearer","starlette.requests.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of HTTPBearer","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"UnionType","items":["fastapi.security.http.HTTPAuthorizationCredentials",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5],"arg_names":["self","bearerFormat","scheme_name","description","auto_error"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"fastapi.security.http.HTTPBearer.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":["self","bearerFormat","scheme_name","description","auto_error"],"arg_types":["fastapi.security.http.HTTPBearer",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of HTTPBearer","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.security.http.HTTPBearer.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.security.http.HTTPBearer","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"HTTPBearerModel":{".class":"SymbolTableNode","cross_ref":"fastapi.openapi.models.HTTPBearer","kind":"Gdef"},"HTTPDigest":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.security.http.HTTPBase"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.security.http.HTTPDigest","name":"HTTPDigest","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.security.http.HTTPDigest","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"fastapi.security.http","mro":["fastapi.security.http.HTTPDigest","fastapi.security.http.HTTPBase","fastapi.security.base.SecurityBase","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"fastapi.security.http.HTTPDigest.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["fastapi.security.http.HTTPDigest","starlette.requests.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of HTTPDigest","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"UnionType","items":["fastapi.security.http.HTTPAuthorizationCredentials",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5],"arg_names":["self","scheme_name","description","auto_error"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"fastapi.security.http.HTTPDigest.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":["self","scheme_name","description","auto_error"],"arg_types":["fastapi.security.http.HTTPDigest",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of HTTPDigest","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.security.http.HTTPDigest.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.security.http.HTTPDigest","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"HTTPException":{".class":"SymbolTableNode","cross_ref":"fastapi.exceptions.HTTPException","kind":"Gdef"},"HTTP_401_UNAUTHORIZED":{".class":"SymbolTableNode","cross_ref":"starlette.status.HTTP_401_UNAUTHORIZED","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"Request":{".class":"SymbolTableNode","cross_ref":"starlette.requests.Request","kind":"Gdef"},"SecurityBase":{".class":"SymbolTableNode","cross_ref":"fastapi.security.base.SecurityBase","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.http.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.http.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.http.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.http.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.http.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.http.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"b64decode":{".class":"SymbolTableNode","cross_ref":"base64.b64decode","kind":"Gdef"},"binascii":{".class":"SymbolTableNode","cross_ref":"binascii","kind":"Gdef"},"get_authorization_scheme_param":{".class":"SymbolTableNode","cross_ref":"fastapi.security.utils.get_authorization_scheme_param","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/security/http.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/http.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/http.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..506579eff7bc2629077cb2aee7d7bb8b1b2a3e07 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/http.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106718,"dep_lines":[7,9,10,6,12,13,1,2,3,5,11,14,1,1,1,1,1,1,1,1,1,1],"dep_prios":[5,5,5,5,5,5,10,5,5,5,5,5,5,30,30,30,30,30,30,30,30,30],"dependencies":["fastapi.openapi.models","fastapi.security.base","fastapi.security.utils","fastapi.exceptions","starlette.requests","starlette.status","binascii","base64","typing","annotated_doc","pydantic","typing_extensions","builtins","_frozen_importlib","abc","enum","fastapi.openapi","pydantic._internal","pydantic._internal._model_construction","pydantic.main","starlette","starlette.exceptions"],"hash":"ecaf8741e844da33142f2974131d0ee530da146d","id":"fastapi.security.http","ignore_all":true,"interface_hash":"159078be21ab9ee0e96f1ceb8f07dd1a0bd62d44","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/security/http.py","plugin_data":null,"size":13553,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/oauth2.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/oauth2.data.json new file mode 100644 index 0000000000000000000000000000000000000000..da7a6c6004143497df9bf750922bd51fb8e48a6a --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/oauth2.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"fastapi.security.oauth2","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Annotated":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Annotated","kind":"Gdef"},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"Dict":{".class":"SymbolTableNode","cross_ref":"typing.Dict","kind":"Gdef"},"Doc":{".class":"SymbolTableNode","cross_ref":"annotated_doc.main.Doc","kind":"Gdef"},"Form":{".class":"SymbolTableNode","cross_ref":"fastapi.param_functions.Form","kind":"Gdef"},"HTTPException":{".class":"SymbolTableNode","cross_ref":"fastapi.exceptions.HTTPException","kind":"Gdef"},"HTTP_401_UNAUTHORIZED":{".class":"SymbolTableNode","cross_ref":"starlette.status.HTTP_401_UNAUTHORIZED","kind":"Gdef"},"List":{".class":"SymbolTableNode","cross_ref":"typing.List","kind":"Gdef"},"OAuth2":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.security.base.SecurityBase"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.security.oauth2.OAuth2","name":"OAuth2","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.security.oauth2.OAuth2","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"fastapi.security.oauth2","mro":["fastapi.security.oauth2.OAuth2","fastapi.security.base.SecurityBase","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"fastapi.security.oauth2.OAuth2.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["fastapi.security.oauth2.OAuth2","starlette.requests.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of OAuth2","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5],"arg_names":["self","flows","scheme_name","description","auto_error"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"fastapi.security.oauth2.OAuth2.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":["self","flows","scheme_name","description","auto_error"],"arg_types":["fastapi.security.oauth2.OAuth2",{".class":"UnionType","items":["fastapi.openapi.models.OAuthFlows",{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of OAuth2","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"auto_error":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"fastapi.security.oauth2.OAuth2.auto_error","name":"auto_error","setter_type":null,"type":"builtins.bool"}},"make_not_authenticated_error":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"fastapi.security.oauth2.OAuth2.make_not_authenticated_error","name":"make_not_authenticated_error","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi.security.oauth2.OAuth2"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"make_not_authenticated_error of OAuth2","ret_type":"fastapi.exceptions.HTTPException","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.security.oauth2.OAuth2.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.security.oauth2.OAuth2","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"OAuth2AuthorizationCodeBearer":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.security.oauth2.OAuth2"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.security.oauth2.OAuth2AuthorizationCodeBearer","name":"OAuth2AuthorizationCodeBearer","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.security.oauth2.OAuth2AuthorizationCodeBearer","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"fastapi.security.oauth2","mro":["fastapi.security.oauth2.OAuth2AuthorizationCodeBearer","fastapi.security.oauth2.OAuth2","fastapi.security.base.SecurityBase","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"fastapi.security.oauth2.OAuth2AuthorizationCodeBearer.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["fastapi.security.oauth2.OAuth2AuthorizationCodeBearer","starlette.requests.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of OAuth2AuthorizationCodeBearer","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1,1,1],"arg_names":["self","authorizationUrl","tokenUrl","refreshUrl","scheme_name","scopes","description","auto_error"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"fastapi.security.oauth2.OAuth2AuthorizationCodeBearer.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1,1],"arg_names":["self","authorizationUrl","tokenUrl","refreshUrl","scheme_name","scopes","description","auto_error"],"arg_types":["fastapi.security.oauth2.OAuth2AuthorizationCodeBearer","builtins.str","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of OAuth2AuthorizationCodeBearer","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.security.oauth2.OAuth2AuthorizationCodeBearer.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.security.oauth2.OAuth2AuthorizationCodeBearer","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"OAuth2Model":{".class":"SymbolTableNode","cross_ref":"fastapi.openapi.models.OAuth2","kind":"Gdef"},"OAuth2PasswordBearer":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.security.oauth2.OAuth2"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.security.oauth2.OAuth2PasswordBearer","name":"OAuth2PasswordBearer","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.security.oauth2.OAuth2PasswordBearer","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"fastapi.security.oauth2","mro":["fastapi.security.oauth2.OAuth2PasswordBearer","fastapi.security.oauth2.OAuth2","fastapi.security.base.SecurityBase","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"fastapi.security.oauth2.OAuth2PasswordBearer.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["fastapi.security.oauth2.OAuth2PasswordBearer","starlette.requests.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of OAuth2PasswordBearer","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1],"arg_names":["self","tokenUrl","scheme_name","scopes","description","auto_error","refreshUrl"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"fastapi.security.oauth2.OAuth2PasswordBearer.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":["self","tokenUrl","scheme_name","scopes","description","auto_error","refreshUrl"],"arg_types":["fastapi.security.oauth2.OAuth2PasswordBearer","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of OAuth2PasswordBearer","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.security.oauth2.OAuth2PasswordBearer.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.security.oauth2.OAuth2PasswordBearer","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"OAuth2PasswordRequestForm":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.security.oauth2.OAuth2PasswordRequestForm","name":"OAuth2PasswordRequestForm","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.security.oauth2.OAuth2PasswordRequestForm","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"fastapi.security.oauth2","mro":["fastapi.security.oauth2.OAuth2PasswordRequestForm","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,3,3,5,5,5],"arg_names":["self","grant_type","username","password","scope","client_id","client_secret"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"fastapi.security.oauth2.OAuth2PasswordRequestForm.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,3,3,5,5,5],"arg_names":["self","grant_type","username","password","scope","client_id","client_secret"],"arg_types":["fastapi.security.oauth2.OAuth2PasswordRequestForm",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str","builtins.str","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of OAuth2PasswordRequestForm","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"client_id":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"fastapi.security.oauth2.OAuth2PasswordRequestForm.client_id","name":"client_id","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"client_secret":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"fastapi.security.oauth2.OAuth2PasswordRequestForm.client_secret","name":"client_secret","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"grant_type":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"fastapi.security.oauth2.OAuth2PasswordRequestForm.grant_type","name":"grant_type","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"password":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"fastapi.security.oauth2.OAuth2PasswordRequestForm.password","name":"password","setter_type":null,"type":"builtins.str"}},"scopes":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"fastapi.security.oauth2.OAuth2PasswordRequestForm.scopes","name":"scopes","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"username":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"fastapi.security.oauth2.OAuth2PasswordRequestForm.username","name":"username","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.security.oauth2.OAuth2PasswordRequestForm.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.security.oauth2.OAuth2PasswordRequestForm","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"OAuth2PasswordRequestFormStrict":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.security.oauth2.OAuth2PasswordRequestForm"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.security.oauth2.OAuth2PasswordRequestFormStrict","name":"OAuth2PasswordRequestFormStrict","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.security.oauth2.OAuth2PasswordRequestFormStrict","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"fastapi.security.oauth2","mro":["fastapi.security.oauth2.OAuth2PasswordRequestFormStrict","fastapi.security.oauth2.OAuth2PasswordRequestForm","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1,1,1],"arg_names":["self","grant_type","username","password","scope","client_id","client_secret"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"fastapi.security.oauth2.OAuth2PasswordRequestFormStrict.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1],"arg_names":["self","grant_type","username","password","scope","client_id","client_secret"],"arg_types":["fastapi.security.oauth2.OAuth2PasswordRequestFormStrict","builtins.str","builtins.str","builtins.str","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of OAuth2PasswordRequestFormStrict","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.security.oauth2.OAuth2PasswordRequestFormStrict.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.security.oauth2.OAuth2PasswordRequestFormStrict","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"OAuthFlowsModel":{".class":"SymbolTableNode","cross_ref":"fastapi.openapi.models.OAuthFlows","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"Request":{".class":"SymbolTableNode","cross_ref":"starlette.requests.Request","kind":"Gdef"},"SecurityBase":{".class":"SymbolTableNode","cross_ref":"fastapi.security.base.SecurityBase","kind":"Gdef"},"SecurityScopes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.security.oauth2.SecurityScopes","name":"SecurityScopes","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.security.oauth2.SecurityScopes","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"fastapi.security.oauth2","mro":["fastapi.security.oauth2.SecurityScopes","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","scopes"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"fastapi.security.oauth2.SecurityScopes.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","scopes"],"arg_types":["fastapi.security.oauth2.SecurityScopes",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of SecurityScopes","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"scope_str":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"fastapi.security.oauth2.SecurityScopes.scope_str","name":"scope_str","setter_type":null,"type":"builtins.str"}},"scopes":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"fastapi.security.oauth2.SecurityScopes.scopes","name":"scopes","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.security.oauth2.SecurityScopes.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.security.oauth2.SecurityScopes","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.oauth2.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.oauth2.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.oauth2.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.oauth2.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.oauth2.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.oauth2.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"cast":{".class":"SymbolTableNode","cross_ref":"typing.cast","kind":"Gdef"},"get_authorization_scheme_param":{".class":"SymbolTableNode","cross_ref":"fastapi.security.utils.get_authorization_scheme_param","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/security/oauth2.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/oauth2.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/oauth2.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..2eaa4c4f3920d48c5ea80567ec2973780290950b --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/oauth2.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106718,"dep_lines":[5,8,9,4,7,10,11,1,3,14,1,1,1,1,1,1,1,1,1,1,1],"dep_prios":[5,5,5,5,5,5,5,5,5,5,5,30,30,30,30,30,30,30,30,30,30],"dependencies":["fastapi.openapi.models","fastapi.security.base","fastapi.security.utils","fastapi.exceptions","fastapi.param_functions","starlette.requests","starlette.status","typing","annotated_doc","typing_extensions","builtins","_frozen_importlib","abc","enum","fastapi.openapi","pydantic","pydantic._internal","pydantic._internal._model_construction","pydantic.main","starlette","starlette.exceptions"],"hash":"fb6ffc3f24b24100f6a1443fa02edfc76feaac5f","id":"fastapi.security.oauth2","ignore_all":true,"interface_hash":"3e8895b4898cc0e9f73639e5c2789a21e69fac23","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/security/oauth2.py","plugin_data":null,"size":22574,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/open_id_connect_url.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/open_id_connect_url.data.json new file mode 100644 index 0000000000000000000000000000000000000000..aa7c2121963f39bdc936d741ff18a924095ac657 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/open_id_connect_url.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"fastapi.security.open_id_connect_url","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Annotated":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Annotated","kind":"Gdef"},"Doc":{".class":"SymbolTableNode","cross_ref":"annotated_doc.main.Doc","kind":"Gdef"},"HTTPException":{".class":"SymbolTableNode","cross_ref":"starlette.exceptions.HTTPException","kind":"Gdef"},"HTTP_401_UNAUTHORIZED":{".class":"SymbolTableNode","cross_ref":"starlette.status.HTTP_401_UNAUTHORIZED","kind":"Gdef"},"OpenIdConnect":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["fastapi.security.base.SecurityBase"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"fastapi.security.open_id_connect_url.OpenIdConnect","name":"OpenIdConnect","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"fastapi.security.open_id_connect_url.OpenIdConnect","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"fastapi.security.open_id_connect_url","mro":["fastapi.security.open_id_connect_url.OpenIdConnect","fastapi.security.base.SecurityBase","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"fastapi.security.open_id_connect_url.OpenIdConnect.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["fastapi.security.open_id_connect_url.OpenIdConnect","starlette.requests.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of OpenIdConnect","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,5,5,5],"arg_names":["self","openIdConnectUrl","scheme_name","description","auto_error"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"fastapi.security.open_id_connect_url.OpenIdConnect.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3,5,5,5],"arg_names":["self","openIdConnectUrl","scheme_name","description","auto_error"],"arg_types":["fastapi.security.open_id_connect_url.OpenIdConnect","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of OpenIdConnect","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"auto_error":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"fastapi.security.open_id_connect_url.OpenIdConnect.auto_error","name":"auto_error","setter_type":null,"type":"builtins.bool"}},"make_not_authenticated_error":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"fastapi.security.open_id_connect_url.OpenIdConnect.make_not_authenticated_error","name":"make_not_authenticated_error","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["fastapi.security.open_id_connect_url.OpenIdConnect"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"make_not_authenticated_error of OpenIdConnect","ret_type":"starlette.exceptions.HTTPException","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"fastapi.security.open_id_connect_url.OpenIdConnect.Self","id":0,"name":"Self","namespace":"","upper_bound":"fastapi.security.open_id_connect_url.OpenIdConnect","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"OpenIdConnectModel":{".class":"SymbolTableNode","cross_ref":"fastapi.openapi.models.OpenIdConnect","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"Request":{".class":"SymbolTableNode","cross_ref":"starlette.requests.Request","kind":"Gdef"},"SecurityBase":{".class":"SymbolTableNode","cross_ref":"fastapi.security.base.SecurityBase","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.open_id_connect_url.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.open_id_connect_url.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.open_id_connect_url.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.open_id_connect_url.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.open_id_connect_url.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.open_id_connect_url.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/security/open_id_connect_url.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/open_id_connect_url.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/open_id_connect_url.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..56c845d3ec20f46cf42c02ab8319f5f332105046 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/open_id_connect_url.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106718,"dep_lines":[4,5,6,7,8,1,3,9,1,1,1,1,1,1,1,1,1,1],"dep_prios":[5,5,5,5,5,5,5,5,5,30,30,30,30,30,30,30,30,30],"dependencies":["fastapi.openapi.models","fastapi.security.base","starlette.exceptions","starlette.requests","starlette.status","typing","annotated_doc","typing_extensions","builtins","_frozen_importlib","abc","enum","fastapi.openapi","pydantic","pydantic._internal","pydantic._internal._model_construction","pydantic.main","starlette"],"hash":"9accd0b1684c0e9e915807b11c8b5b476bf5f090","id":"fastapi.security.open_id_connect_url","ignore_all":true,"interface_hash":"c1960aef2fcb118d676411d4d9b9fa6b6b8f9f77","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/security/open_id_connect_url.py","plugin_data":null,"size":3187,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/utils.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/utils.data.json new file mode 100644 index 0000000000000000000000000000000000000000..fa83adcba7751cc5e8b0ec52ba888a19d894b148 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/utils.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"fastapi.security.utils","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"Tuple":{".class":"SymbolTableNode","cross_ref":"typing.Tuple","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.utils.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.utils.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.utils.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.utils.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.utils.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"fastapi.security.utils.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"get_authorization_scheme_param":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["authorization_header_value"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"fastapi.security.utils.get_authorization_scheme_param","name":"get_authorization_scheme_param","original_first_arg":"authorization_header_value","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["authorization_header_value"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_authorization_scheme_param","ret_type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/security/utils.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/utils.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/utils.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..6ca83e6508db07e2ea90c93118397252ebecbc1e --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/fastapi/security/utils.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106713,"dep_lines":[1,1,1,1],"dep_prios":[5,5,30,30],"dependencies":["typing","builtins","_frozen_importlib","abc"],"hash":"e4a6a5290e417ce26f2da68edc1614781ddbc21b","id":"fastapi.security.utils","ignore_all":true,"interface_hash":"420ba9b01f75a8e7c50a2b1d1b2e2c055ce26069","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/fastapi/security/utils.py","plugin_data":null,"size":293,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..e23a35a4ebcf94d16a4baba8306d4a1c268b0dfb --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"httpcore._async","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","AsyncConnectionInterface":{".class":"SymbolTableNode","cross_ref":"httpcore._async.interfaces.AsyncConnectionInterface","kind":"Gdef"},"AsyncConnectionPool":{".class":"SymbolTableNode","cross_ref":"httpcore._async.connection_pool.AsyncConnectionPool","kind":"Gdef"},"AsyncHTTP11Connection":{".class":"SymbolTableNode","cross_ref":"httpcore._async.http11.AsyncHTTP11Connection","kind":"Gdef"},"AsyncHTTP2Connection":{".class":"SymbolTableNode","cross_ref":"httpcore._async.http2.AsyncHTTP2Connection","kind":"Gdef"},"AsyncHTTPConnection":{".class":"SymbolTableNode","cross_ref":"httpcore._async.connection.AsyncHTTPConnection","kind":"Gdef"},"AsyncHTTPProxy":{".class":"SymbolTableNode","cross_ref":"httpcore._async.http_proxy.AsyncHTTPProxy","kind":"Gdef"},"AsyncSOCKSProxy":{".class":"SymbolTableNode","cross_ref":"httpcore._async.socks_proxy.AsyncSOCKSProxy","kind":"Gdef"},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._async.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_async/__init__.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..2656bc01b682fd290663ac7c1cb915aa5610e442 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,2,3,4,5,8,20,1,1,1,1],"dep_prios":[5,5,5,5,5,5,5,5,30,30,30],"dependencies":["httpcore._async.connection","httpcore._async.connection_pool","httpcore._async.http11","httpcore._async.http_proxy","httpcore._async.interfaces","httpcore._async.http2","httpcore._async.socks_proxy","builtins","_frozen_importlib","abc","typing"],"hash":"b229f232e43d292ba57d309b82fed0e0ee362493","id":"httpcore._async","ignore_all":true,"interface_hash":"6bb70304b9277b939b5789f26971d98ff4f2eca8","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_async/__init__.py","plugin_data":null,"size":1221,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/connection.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/connection.data.json new file mode 100644 index 0000000000000000000000000000000000000000..0ee3fd7cd2b800a91324f2bcd70d2f7eaff6ef91 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/connection.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"httpcore._async.connection","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","AsyncConnectionInterface":{".class":"SymbolTableNode","cross_ref":"httpcore._async.interfaces.AsyncConnectionInterface","kind":"Gdef"},"AsyncHTTP11Connection":{".class":"SymbolTableNode","cross_ref":"httpcore._async.http11.AsyncHTTP11Connection","kind":"Gdef"},"AsyncHTTPConnection":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["httpcore._async.interfaces.AsyncConnectionInterface"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._async.connection.AsyncHTTPConnection","name":"AsyncHTTPConnection","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._async.connection.AsyncHTTPConnection","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._async.connection","mro":["httpcore._async.connection.AsyncHTTPConnection","httpcore._async.interfaces.AsyncConnectionInterface","httpcore._async.interfaces.AsyncRequestInterface","builtins.object"],"names":{".class":"SymbolTable","__aenter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.connection.AsyncHTTPConnection.__aenter__","name":"__aenter__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.connection.AsyncHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__aenter__ of AsyncHTTPConnection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"httpcore._async.connection.AsyncHTTPConnection"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__aexit__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","exc_type","exc_value","traceback"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.connection.AsyncHTTPConnection.__aexit__","name":"__aexit__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","exc_type","exc_value","traceback"],"arg_types":["httpcore._async.connection.AsyncHTTPConnection",{".class":"UnionType","items":[{".class":"TypeType","item":"builtins.BaseException"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.BaseException",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["types.TracebackType",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__aexit__ of AsyncHTTPConnection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,1,1,1,1],"arg_names":["self","origin","ssl_context","keepalive_expiry","http1","http2","retries","local_address","uds","network_backend","socket_options"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.connection.AsyncHTTPConnection.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1,1,1,1],"arg_names":["self","origin","ssl_context","keepalive_expiry","http1","http2","retries","local_address","uds","network_backend","socket_options"],"arg_types":["httpcore._async.connection.AsyncHTTPConnection","httpcore._models.Origin",{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool","builtins.int",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["httpcore._backends.base.AsyncNetworkBackend",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._backends.base.SOCKET_OPTION"}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of AsyncHTTPConnection","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.connection.AsyncHTTPConnection.__repr__","name":"__repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["httpcore._async.connection.AsyncHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr__ of AsyncHTTPConnection","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_connect":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.connection.AsyncHTTPConnection._connect","name":"_connect","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["httpcore._async.connection.AsyncHTTPConnection","httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_connect of AsyncHTTPConnection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"httpcore._backends.base.AsyncNetworkStream"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_connect_failed":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._async.connection.AsyncHTTPConnection._connect_failed","name":"_connect_failed","setter_type":null,"type":"builtins.bool"}},"_connection":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._async.connection.AsyncHTTPConnection._connection","name":"_connection","setter_type":null,"type":{".class":"UnionType","items":["httpcore._async.interfaces.AsyncConnectionInterface",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_http1":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.connection.AsyncHTTPConnection._http1","name":"_http1","setter_type":null,"type":"builtins.bool"}},"_http2":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.connection.AsyncHTTPConnection._http2","name":"_http2","setter_type":null,"type":"builtins.bool"}},"_keepalive_expiry":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.connection.AsyncHTTPConnection._keepalive_expiry","name":"_keepalive_expiry","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_local_address":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.connection.AsyncHTTPConnection._local_address","name":"_local_address","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_network_backend":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._async.connection.AsyncHTTPConnection._network_backend","name":"_network_backend","setter_type":null,"type":"httpcore._backends.base.AsyncNetworkBackend"}},"_origin":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.connection.AsyncHTTPConnection._origin","name":"_origin","setter_type":null,"type":"httpcore._models.Origin"}},"_request_lock":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.connection.AsyncHTTPConnection._request_lock","name":"_request_lock","setter_type":null,"type":"httpcore._synchronization.AsyncLock"}},"_retries":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.connection.AsyncHTTPConnection._retries","name":"_retries","setter_type":null,"type":"builtins.int"}},"_socket_options":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.connection.AsyncHTTPConnection._socket_options","name":"_socket_options","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._backends.base.SOCKET_OPTION"}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_ssl_context":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.connection.AsyncHTTPConnection._ssl_context","name":"_ssl_context","setter_type":null,"type":{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_uds":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.connection.AsyncHTTPConnection._uds","name":"_uds","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"aclose":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.connection.AsyncHTTPConnection.aclose","name":"aclose","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.connection.AsyncHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"aclose of AsyncHTTPConnection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"can_handle_request":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","origin"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.connection.AsyncHTTPConnection.can_handle_request","name":"can_handle_request","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","origin"],"arg_types":["httpcore._async.connection.AsyncHTTPConnection","httpcore._models.Origin"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"can_handle_request of AsyncHTTPConnection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"handle_async_request":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.connection.AsyncHTTPConnection.handle_async_request","name":"handle_async_request","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["httpcore._async.connection.AsyncHTTPConnection","httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"handle_async_request of AsyncHTTPConnection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"httpcore._models.Response"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"has_expired":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.connection.AsyncHTTPConnection.has_expired","name":"has_expired","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.connection.AsyncHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"has_expired of AsyncHTTPConnection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"info":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.connection.AsyncHTTPConnection.info","name":"info","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.connection.AsyncHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"info of AsyncHTTPConnection","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_available":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.connection.AsyncHTTPConnection.is_available","name":"is_available","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.connection.AsyncHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_available of AsyncHTTPConnection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_closed":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.connection.AsyncHTTPConnection.is_closed","name":"is_closed","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.connection.AsyncHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_closed of AsyncHTTPConnection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_idle":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.connection.AsyncHTTPConnection.is_idle","name":"is_idle","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.connection.AsyncHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_idle of AsyncHTTPConnection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._async.connection.AsyncHTTPConnection.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._async.connection.AsyncHTTPConnection","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"AsyncLock":{".class":"SymbolTableNode","cross_ref":"httpcore._synchronization.AsyncLock","kind":"Gdef"},"AsyncNetworkBackend":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.AsyncNetworkBackend","kind":"Gdef"},"AsyncNetworkStream":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.AsyncNetworkStream","kind":"Gdef"},"AutoBackend":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.auto.AutoBackend","kind":"Gdef"},"ConnectError":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.ConnectError","kind":"Gdef"},"ConnectTimeout":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.ConnectTimeout","kind":"Gdef"},"Origin":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Origin","kind":"Gdef"},"RETRIES_BACKOFF_FACTOR":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._async.connection.RETRIES_BACKOFF_FACTOR","name":"RETRIES_BACKOFF_FACTOR","setter_type":null,"type":"builtins.float"}},"Request":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Request","kind":"Gdef"},"Response":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Response","kind":"Gdef"},"SOCKET_OPTION":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.SOCKET_OPTION","kind":"Gdef"},"Trace":{".class":"SymbolTableNode","cross_ref":"httpcore._trace.Trace","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.connection.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.connection.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.connection.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.connection.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.connection.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.connection.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"default_ssl_context":{".class":"SymbolTableNode","cross_ref":"httpcore._ssl.default_ssl_context","kind":"Gdef"},"exponential_backoff":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["factor"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"httpcore._async.connection.exponential_backoff","name":"exponential_backoff","original_first_arg":"factor","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["factor"],"arg_types":["builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"exponential_backoff","ret_type":{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"typing.Iterator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"itertools":{".class":"SymbolTableNode","cross_ref":"itertools","kind":"Gdef"},"logger":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._async.connection.logger","name":"logger","setter_type":null,"type":"logging.Logger"}},"logging":{".class":"SymbolTableNode","cross_ref":"logging","kind":"Gdef"},"ssl":{".class":"SymbolTableNode","cross_ref":"ssl","kind":"Gdef"},"types":{".class":"SymbolTableNode","cross_ref":"types","kind":"Gdef"},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_async/connection.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/connection.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/connection.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..7c120d20b3471b1f81491a5a3bcefa9c32fa0b4d --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/connection.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[9,10,16,17,86,11,12,13,14,15,1,3,4,5,6,7,1,1,1,1,1],"dep_prios":[5,5,5,5,20,5,5,5,5,5,5,10,10,10,10,10,5,30,30,30,30],"dependencies":["httpcore._backends.auto","httpcore._backends.base","httpcore._async.http11","httpcore._async.interfaces","httpcore._async.http2","httpcore._exceptions","httpcore._models","httpcore._ssl","httpcore._synchronization","httpcore._trace","__future__","itertools","logging","ssl","types","typing","builtins","_frozen_importlib","_ssl","abc","httpcore._backends"],"hash":"448a066ee2ddc686dafdb1cc14b4dfc212306ccf","id":"httpcore._async.connection","ignore_all":true,"interface_hash":"379d86d49bfa54a45812b0b143e9dce72d9dded7","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_async/connection.py","plugin_data":null,"size":8449,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/connection_pool.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/connection_pool.data.json new file mode 100644 index 0000000000000000000000000000000000000000..d43a1d037c0c6726748729e13f1a02debff4c7d6 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/connection_pool.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"httpcore._async.connection_pool","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","AsyncConnectionInterface":{".class":"SymbolTableNode","cross_ref":"httpcore._async.interfaces.AsyncConnectionInterface","kind":"Gdef"},"AsyncConnectionPool":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["httpcore._async.interfaces.AsyncRequestInterface"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._async.connection_pool.AsyncConnectionPool","name":"AsyncConnectionPool","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._async.connection_pool.AsyncConnectionPool","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._async.connection_pool","mro":["httpcore._async.connection_pool.AsyncConnectionPool","httpcore._async.interfaces.AsyncRequestInterface","builtins.object"],"names":{".class":"SymbolTable","__aenter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.connection_pool.AsyncConnectionPool.__aenter__","name":"__aenter__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.connection_pool.AsyncConnectionPool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__aenter__ of AsyncConnectionPool","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"httpcore._async.connection_pool.AsyncConnectionPool"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__aexit__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","exc_type","exc_value","traceback"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.connection_pool.AsyncConnectionPool.__aexit__","name":"__aexit__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","exc_type","exc_value","traceback"],"arg_types":["httpcore._async.connection_pool.AsyncConnectionPool",{".class":"UnionType","items":[{".class":"TypeType","item":"builtins.BaseException"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.BaseException",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["types.TracebackType",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__aexit__ of AsyncConnectionPool","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1,1,1,1,1,1,1],"arg_names":["self","ssl_context","proxy","max_connections","max_keepalive_connections","keepalive_expiry","http1","http2","retries","local_address","uds","network_backend","socket_options"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.connection_pool.AsyncConnectionPool.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,1,1,1,1,1,1],"arg_names":["self","ssl_context","proxy","max_connections","max_keepalive_connections","keepalive_expiry","http1","http2","retries","local_address","uds","network_backend","socket_options"],"arg_types":["httpcore._async.connection_pool.AsyncConnectionPool",{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["httpcore._models.Proxy",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool","builtins.int",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["httpcore._backends.base.AsyncNetworkBackend",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._backends.base.SOCKET_OPTION"}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of AsyncConnectionPool","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.connection_pool.AsyncConnectionPool.__repr__","name":"__repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["httpcore._async.connection_pool.AsyncConnectionPool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr__ of AsyncConnectionPool","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_assign_requests_to_connections":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.connection_pool.AsyncConnectionPool._assign_requests_to_connections","name":"_assign_requests_to_connections","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.connection_pool.AsyncConnectionPool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_assign_requests_to_connections of AsyncConnectionPool","ret_type":{".class":"Instance","args":["httpcore._async.interfaces.AsyncConnectionInterface"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_close_connections":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","closing"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.connection_pool.AsyncConnectionPool._close_connections","name":"_close_connections","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","closing"],"arg_types":["httpcore._async.connection_pool.AsyncConnectionPool",{".class":"Instance","args":["httpcore._async.interfaces.AsyncConnectionInterface"],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_close_connections of AsyncConnectionPool","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_connections":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._async.connection_pool.AsyncConnectionPool._connections","name":"_connections","setter_type":null,"type":{".class":"Instance","args":["httpcore._async.interfaces.AsyncConnectionInterface"],"extra_attrs":null,"type_ref":"builtins.list"}}},"_http1":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.connection_pool.AsyncConnectionPool._http1","name":"_http1","setter_type":null,"type":"builtins.bool"}},"_http2":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.connection_pool.AsyncConnectionPool._http2","name":"_http2","setter_type":null,"type":"builtins.bool"}},"_keepalive_expiry":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.connection_pool.AsyncConnectionPool._keepalive_expiry","name":"_keepalive_expiry","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_local_address":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.connection_pool.AsyncConnectionPool._local_address","name":"_local_address","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_max_connections":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.connection_pool.AsyncConnectionPool._max_connections","name":"_max_connections","setter_type":null,"type":"builtins.int"}},"_max_keepalive_connections":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.connection_pool.AsyncConnectionPool._max_keepalive_connections","name":"_max_keepalive_connections","setter_type":null,"type":"builtins.int"}},"_network_backend":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.connection_pool.AsyncConnectionPool._network_backend","name":"_network_backend","setter_type":null,"type":"httpcore._backends.base.AsyncNetworkBackend"}},"_optional_thread_lock":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.connection_pool.AsyncConnectionPool._optional_thread_lock","name":"_optional_thread_lock","setter_type":null,"type":"httpcore._synchronization.AsyncThreadLock"}},"_proxy":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.connection_pool.AsyncConnectionPool._proxy","name":"_proxy","setter_type":null,"type":{".class":"UnionType","items":["httpcore._models.Proxy",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_requests":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._async.connection_pool.AsyncConnectionPool._requests","name":"_requests","setter_type":null,"type":{".class":"Instance","args":["httpcore._async.connection_pool.AsyncPoolRequest"],"extra_attrs":null,"type_ref":"builtins.list"}}},"_retries":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.connection_pool.AsyncConnectionPool._retries","name":"_retries","setter_type":null,"type":"builtins.int"}},"_socket_options":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.connection_pool.AsyncConnectionPool._socket_options","name":"_socket_options","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._backends.base.SOCKET_OPTION"}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_ssl_context":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.connection_pool.AsyncConnectionPool._ssl_context","name":"_ssl_context","setter_type":null,"type":{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_uds":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.connection_pool.AsyncConnectionPool._uds","name":"_uds","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"aclose":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.connection_pool.AsyncConnectionPool.aclose","name":"aclose","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.connection_pool.AsyncConnectionPool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"aclose of AsyncConnectionPool","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"connections":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"httpcore._async.connection_pool.AsyncConnectionPool.connections","name":"connections","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.connection_pool.AsyncConnectionPool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"connections of AsyncConnectionPool","ret_type":{".class":"Instance","args":["httpcore._async.interfaces.AsyncConnectionInterface"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"httpcore._async.connection_pool.AsyncConnectionPool.connections","name":"connections","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.connection_pool.AsyncConnectionPool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"connections of AsyncConnectionPool","ret_type":{".class":"Instance","args":["httpcore._async.interfaces.AsyncConnectionInterface"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"create_connection":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","origin"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.connection_pool.AsyncConnectionPool.create_connection","name":"create_connection","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","origin"],"arg_types":["httpcore._async.connection_pool.AsyncConnectionPool","httpcore._models.Origin"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"create_connection of AsyncConnectionPool","ret_type":"httpcore._async.interfaces.AsyncConnectionInterface","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"handle_async_request":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.connection_pool.AsyncConnectionPool.handle_async_request","name":"handle_async_request","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["httpcore._async.connection_pool.AsyncConnectionPool","httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"handle_async_request of AsyncConnectionPool","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"httpcore._models.Response"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._async.connection_pool.AsyncConnectionPool.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._async.connection_pool.AsyncConnectionPool","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"AsyncEvent":{".class":"SymbolTableNode","cross_ref":"httpcore._synchronization.AsyncEvent","kind":"Gdef"},"AsyncHTTPConnection":{".class":"SymbolTableNode","cross_ref":"httpcore._async.connection.AsyncHTTPConnection","kind":"Gdef"},"AsyncNetworkBackend":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.AsyncNetworkBackend","kind":"Gdef"},"AsyncPoolRequest":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._async.connection_pool.AsyncPoolRequest","name":"AsyncPoolRequest","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._async.connection_pool.AsyncPoolRequest","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._async.connection_pool","mro":["httpcore._async.connection_pool.AsyncPoolRequest","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.connection_pool.AsyncPoolRequest.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["httpcore._async.connection_pool.AsyncPoolRequest","httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of AsyncPoolRequest","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_connection_acquired":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.connection_pool.AsyncPoolRequest._connection_acquired","name":"_connection_acquired","setter_type":null,"type":"httpcore._synchronization.AsyncEvent"}},"assign_to_connection":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","connection"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.connection_pool.AsyncPoolRequest.assign_to_connection","name":"assign_to_connection","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","connection"],"arg_types":["httpcore._async.connection_pool.AsyncPoolRequest",{".class":"UnionType","items":["httpcore._async.interfaces.AsyncConnectionInterface",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assign_to_connection of AsyncPoolRequest","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"clear_connection":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.connection_pool.AsyncPoolRequest.clear_connection","name":"clear_connection","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.connection_pool.AsyncPoolRequest"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"clear_connection of AsyncPoolRequest","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"connection":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._async.connection_pool.AsyncPoolRequest.connection","name":"connection","setter_type":null,"type":{".class":"UnionType","items":["httpcore._async.interfaces.AsyncConnectionInterface",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"is_queued":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.connection_pool.AsyncPoolRequest.is_queued","name":"is_queued","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.connection_pool.AsyncPoolRequest"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_queued of AsyncPoolRequest","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"request":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.connection_pool.AsyncPoolRequest.request","name":"request","setter_type":null,"type":"httpcore._models.Request"}},"wait_for_connection":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.connection_pool.AsyncPoolRequest.wait_for_connection","name":"wait_for_connection","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","timeout"],"arg_types":["httpcore._async.connection_pool.AsyncPoolRequest",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"wait_for_connection of AsyncPoolRequest","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"httpcore._async.interfaces.AsyncConnectionInterface"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._async.connection_pool.AsyncPoolRequest.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._async.connection_pool.AsyncPoolRequest","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"AsyncRequestInterface":{".class":"SymbolTableNode","cross_ref":"httpcore._async.interfaces.AsyncRequestInterface","kind":"Gdef"},"AsyncShieldCancellation":{".class":"SymbolTableNode","cross_ref":"httpcore._synchronization.AsyncShieldCancellation","kind":"Gdef"},"AsyncThreadLock":{".class":"SymbolTableNode","cross_ref":"httpcore._synchronization.AsyncThreadLock","kind":"Gdef"},"AutoBackend":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.auto.AutoBackend","kind":"Gdef"},"ConnectionNotAvailable":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.ConnectionNotAvailable","kind":"Gdef"},"Origin":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Origin","kind":"Gdef"},"PoolByteStream":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._async.connection_pool.PoolByteStream","name":"PoolByteStream","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._async.connection_pool.PoolByteStream","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._async.connection_pool","mro":["httpcore._async.connection_pool.PoolByteStream","builtins.object"],"names":{".class":"SymbolTable","__aiter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_generator","is_coroutine","is_async_generator","is_trivial_self"],"fullname":"httpcore._async.connection_pool.PoolByteStream.__aiter__","name":"__aiter__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.connection_pool.PoolByteStream"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__aiter__ of PoolByteStream","ret_type":{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.AsyncIterator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","stream","pool_request","pool"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.connection_pool.PoolByteStream.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","stream","pool_request","pool"],"arg_types":["httpcore._async.connection_pool.PoolByteStream",{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.AsyncIterable"},"httpcore._async.connection_pool.AsyncPoolRequest","httpcore._async.connection_pool.AsyncConnectionPool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of PoolByteStream","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_closed":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.connection_pool.PoolByteStream._closed","name":"_closed","setter_type":null,"type":"builtins.bool"}},"_pool":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.connection_pool.PoolByteStream._pool","name":"_pool","setter_type":null,"type":"httpcore._async.connection_pool.AsyncConnectionPool"}},"_pool_request":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.connection_pool.PoolByteStream._pool_request","name":"_pool_request","setter_type":null,"type":"httpcore._async.connection_pool.AsyncPoolRequest"}},"_stream":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.connection_pool.PoolByteStream._stream","name":"_stream","setter_type":null,"type":{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.AsyncIterable"}}},"aclose":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.connection_pool.PoolByteStream.aclose","name":"aclose","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.connection_pool.PoolByteStream"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"aclose of PoolByteStream","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._async.connection_pool.PoolByteStream.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._async.connection_pool.PoolByteStream","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Proxy":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Proxy","kind":"Gdef"},"Request":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Request","kind":"Gdef"},"Response":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Response","kind":"Gdef"},"SOCKET_OPTION":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.SOCKET_OPTION","kind":"Gdef"},"UnsupportedProtocol":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.UnsupportedProtocol","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.connection_pool.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.connection_pool.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.connection_pool.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.connection_pool.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.connection_pool.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.connection_pool.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"ssl":{".class":"SymbolTableNode","cross_ref":"ssl","kind":"Gdef"},"sys":{".class":"SymbolTableNode","cross_ref":"sys","kind":"Gdef"},"types":{".class":"SymbolTableNode","cross_ref":"types","kind":"Gdef"},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_async/connection_pool.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/connection_pool.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/connection_pool.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..bbb9c371ce6e7bbbfe4f77db1ab329b60d8a9173 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/connection_pool.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[8,9,13,14,131,144,10,11,12,1,3,4,5,6,1,1,1,1,1,1],"dep_prios":[5,5,5,5,20,20,5,5,5,5,10,10,10,10,5,30,30,30,30,30],"dependencies":["httpcore._backends.auto","httpcore._backends.base","httpcore._async.connection","httpcore._async.interfaces","httpcore._async.socks_proxy","httpcore._async.http_proxy","httpcore._exceptions","httpcore._models","httpcore._synchronization","__future__","ssl","sys","types","typing","builtins","_frozen_importlib","_ssl","_typeshed","abc","httpcore._backends"],"hash":"5e37f86d5b27f549897fef88a82a146ad8ddff0c","id":"httpcore._async.connection_pool","ignore_all":true,"interface_hash":"309b5208685f65e2a36957c5c1c061c1ae84cdef","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_async/connection_pool.py","plugin_data":null,"size":17307,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/http11.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/http11.data.json new file mode 100644 index 0000000000000000000000000000000000000000..19203830153ff0cb1227d30047614608b655ec7c --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/http11.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"httpcore._async.http11","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","AsyncConnectionInterface":{".class":"SymbolTableNode","cross_ref":"httpcore._async.interfaces.AsyncConnectionInterface","kind":"Gdef"},"AsyncHTTP11Connection":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["httpcore._async.interfaces.AsyncConnectionInterface"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._async.http11.AsyncHTTP11Connection","name":"AsyncHTTP11Connection","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._async.http11.AsyncHTTP11Connection","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._async.http11","mro":["httpcore._async.http11.AsyncHTTP11Connection","httpcore._async.interfaces.AsyncConnectionInterface","httpcore._async.interfaces.AsyncRequestInterface","builtins.object"],"names":{".class":"SymbolTable","MAX_INCOMPLETE_EVENT_SIZE":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._async.http11.AsyncHTTP11Connection.MAX_INCOMPLETE_EVENT_SIZE","name":"MAX_INCOMPLETE_EVENT_SIZE","setter_type":null,"type":"builtins.int"}},"READ_NUM_BYTES":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._async.http11.AsyncHTTP11Connection.READ_NUM_BYTES","name":"READ_NUM_BYTES","setter_type":null,"type":"builtins.int"}},"__aenter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http11.AsyncHTTP11Connection.__aenter__","name":"__aenter__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.http11.AsyncHTTP11Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__aenter__ of AsyncHTTP11Connection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"httpcore._async.http11.AsyncHTTP11Connection"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__aexit__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","exc_type","exc_value","traceback"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http11.AsyncHTTP11Connection.__aexit__","name":"__aexit__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","exc_type","exc_value","traceback"],"arg_types":["httpcore._async.http11.AsyncHTTP11Connection",{".class":"UnionType","items":[{".class":"TypeType","item":"builtins.BaseException"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.BaseException",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["types.TracebackType",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__aexit__ of AsyncHTTP11Connection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","origin","stream","keepalive_expiry"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http11.AsyncHTTP11Connection.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","origin","stream","keepalive_expiry"],"arg_types":["httpcore._async.http11.AsyncHTTP11Connection","httpcore._models.Origin","httpcore._backends.base.AsyncNetworkStream",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of AsyncHTTP11Connection","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http11.AsyncHTTP11Connection.__repr__","name":"__repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["httpcore._async.http11.AsyncHTTP11Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr__ of AsyncHTTP11Connection","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_expire_at":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._async.http11.AsyncHTTP11Connection._expire_at","name":"_expire_at","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_h11_state":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http11.AsyncHTTP11Connection._h11_state","name":"_h11_state","setter_type":null,"type":"h11._connection.Connection"}},"_keepalive_expiry":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._async.http11.AsyncHTTP11Connection._keepalive_expiry","name":"_keepalive_expiry","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_network_stream":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http11.AsyncHTTP11Connection._network_stream","name":"_network_stream","setter_type":null,"type":"httpcore._backends.base.AsyncNetworkStream"}},"_origin":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http11.AsyncHTTP11Connection._origin","name":"_origin","setter_type":null,"type":"httpcore._models.Origin"}},"_receive_event":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http11.AsyncHTTP11Connection._receive_event","name":"_receive_event","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","timeout"],"arg_types":["httpcore._async.http11.AsyncHTTP11Connection",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_receive_event of AsyncHTTP11Connection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"UnionType","items":["h11._events.Event",{".class":"TypeType","item":"h11._connection.PAUSED"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_receive_response_body":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_generator","is_coroutine","is_async_generator","is_trivial_self"],"fullname":"httpcore._async.http11.AsyncHTTP11Connection._receive_response_body","name":"_receive_response_body","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["httpcore._async.http11.AsyncHTTP11Connection","httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_receive_response_body of AsyncHTTP11Connection","ret_type":{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.AsyncIterator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_receive_response_headers":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http11.AsyncHTTP11Connection._receive_response_headers","name":"_receive_response_headers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["httpcore._async.http11.AsyncHTTP11Connection","httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_receive_response_headers of AsyncHTTP11Connection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"TupleType","implicit":false,"items":["builtins.bytes","builtins.int","builtins.bytes",{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.bytes","builtins.bytes"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"builtins.list"},"builtins.bytes"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_request_count":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http11.AsyncHTTP11Connection._request_count","name":"_request_count","setter_type":null,"type":"builtins.int"}},"_response_closed":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http11.AsyncHTTP11Connection._response_closed","name":"_response_closed","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.http11.AsyncHTTP11Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_response_closed of AsyncHTTP11Connection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_send_event":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","event","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http11.AsyncHTTP11Connection._send_event","name":"_send_event","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","event","timeout"],"arg_types":["httpcore._async.http11.AsyncHTTP11Connection","h11._events.Event",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_send_event of AsyncHTTP11Connection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_send_request_body":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http11.AsyncHTTP11Connection._send_request_body","name":"_send_request_body","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["httpcore._async.http11.AsyncHTTP11Connection","httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_send_request_body of AsyncHTTP11Connection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_send_request_headers":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http11.AsyncHTTP11Connection._send_request_headers","name":"_send_request_headers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["httpcore._async.http11.AsyncHTTP11Connection","httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_send_request_headers of AsyncHTTP11Connection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_state":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http11.AsyncHTTP11Connection._state","name":"_state","setter_type":null,"type":"httpcore._async.http11.HTTPConnectionState"}},"_state_lock":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http11.AsyncHTTP11Connection._state_lock","name":"_state_lock","setter_type":null,"type":"httpcore._synchronization.AsyncLock"}},"aclose":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http11.AsyncHTTP11Connection.aclose","name":"aclose","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.http11.AsyncHTTP11Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"aclose of AsyncHTTP11Connection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"can_handle_request":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","origin"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http11.AsyncHTTP11Connection.can_handle_request","name":"can_handle_request","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","origin"],"arg_types":["httpcore._async.http11.AsyncHTTP11Connection","httpcore._models.Origin"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"can_handle_request of AsyncHTTP11Connection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"handle_async_request":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http11.AsyncHTTP11Connection.handle_async_request","name":"handle_async_request","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["httpcore._async.http11.AsyncHTTP11Connection","httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"handle_async_request of AsyncHTTP11Connection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"httpcore._models.Response"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"has_expired":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http11.AsyncHTTP11Connection.has_expired","name":"has_expired","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.http11.AsyncHTTP11Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"has_expired of AsyncHTTP11Connection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"info":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http11.AsyncHTTP11Connection.info","name":"info","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.http11.AsyncHTTP11Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"info of AsyncHTTP11Connection","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_available":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http11.AsyncHTTP11Connection.is_available","name":"is_available","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.http11.AsyncHTTP11Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_available of AsyncHTTP11Connection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_closed":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http11.AsyncHTTP11Connection.is_closed","name":"is_closed","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.http11.AsyncHTTP11Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_closed of AsyncHTTP11Connection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_idle":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http11.AsyncHTTP11Connection.is_idle","name":"is_idle","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.http11.AsyncHTTP11Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_idle of AsyncHTTP11Connection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._async.http11.AsyncHTTP11Connection.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._async.http11.AsyncHTTP11Connection","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"AsyncHTTP11UpgradeStream":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["httpcore._backends.base.AsyncNetworkStream"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._async.http11.AsyncHTTP11UpgradeStream","name":"AsyncHTTP11UpgradeStream","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._async.http11.AsyncHTTP11UpgradeStream","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._async.http11","mro":["httpcore._async.http11.AsyncHTTP11UpgradeStream","httpcore._backends.base.AsyncNetworkStream","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","stream","leading_data"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http11.AsyncHTTP11UpgradeStream.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","stream","leading_data"],"arg_types":["httpcore._async.http11.AsyncHTTP11UpgradeStream","httpcore._backends.base.AsyncNetworkStream","builtins.bytes"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of AsyncHTTP11UpgradeStream","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_leading_data":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http11.AsyncHTTP11UpgradeStream._leading_data","name":"_leading_data","setter_type":null,"type":"builtins.bytes"}},"_stream":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http11.AsyncHTTP11UpgradeStream._stream","name":"_stream","setter_type":null,"type":"httpcore._backends.base.AsyncNetworkStream"}},"aclose":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http11.AsyncHTTP11UpgradeStream.aclose","name":"aclose","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.http11.AsyncHTTP11UpgradeStream"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"aclose of AsyncHTTP11UpgradeStream","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_extra_info":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http11.AsyncHTTP11UpgradeStream.get_extra_info","name":"get_extra_info","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","info"],"arg_types":["httpcore._async.http11.AsyncHTTP11UpgradeStream","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_extra_info of AsyncHTTP11UpgradeStream","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"read":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","max_bytes","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http11.AsyncHTTP11UpgradeStream.read","name":"read","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","max_bytes","timeout"],"arg_types":["httpcore._async.http11.AsyncHTTP11UpgradeStream","builtins.int",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"read of AsyncHTTP11UpgradeStream","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"start_tls":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","ssl_context","server_hostname","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http11.AsyncHTTP11UpgradeStream.start_tls","name":"start_tls","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","ssl_context","server_hostname","timeout"],"arg_types":["httpcore._async.http11.AsyncHTTP11UpgradeStream","ssl.SSLContext",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"start_tls of AsyncHTTP11UpgradeStream","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"httpcore._backends.base.AsyncNetworkStream"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"write":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","buffer","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http11.AsyncHTTP11UpgradeStream.write","name":"write","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","buffer","timeout"],"arg_types":["httpcore._async.http11.AsyncHTTP11UpgradeStream","builtins.bytes",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"write of AsyncHTTP11UpgradeStream","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._async.http11.AsyncHTTP11UpgradeStream.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._async.http11.AsyncHTTP11UpgradeStream","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"AsyncLock":{".class":"SymbolTableNode","cross_ref":"httpcore._synchronization.AsyncLock","kind":"Gdef"},"AsyncNetworkStream":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.AsyncNetworkStream","kind":"Gdef"},"AsyncShieldCancellation":{".class":"SymbolTableNode","cross_ref":"httpcore._synchronization.AsyncShieldCancellation","kind":"Gdef"},"ConnectionNotAvailable":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.ConnectionNotAvailable","kind":"Gdef"},"H11SendEvent":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"httpcore._async.http11.H11SendEvent","line":29,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["h11._events.Request","h11._events.Data","h11._events.EndOfMessage"],"uses_pep604_syntax":false}}},"HTTP11ConnectionByteStream":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._async.http11.HTTP11ConnectionByteStream","name":"HTTP11ConnectionByteStream","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._async.http11.HTTP11ConnectionByteStream","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._async.http11","mro":["httpcore._async.http11.HTTP11ConnectionByteStream","builtins.object"],"names":{".class":"SymbolTable","__aiter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_generator","is_coroutine","is_async_generator","is_trivial_self"],"fullname":"httpcore._async.http11.HTTP11ConnectionByteStream.__aiter__","name":"__aiter__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.http11.HTTP11ConnectionByteStream"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__aiter__ of HTTP11ConnectionByteStream","ret_type":{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.AsyncIterator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","connection","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http11.HTTP11ConnectionByteStream.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","connection","request"],"arg_types":["httpcore._async.http11.HTTP11ConnectionByteStream","httpcore._async.http11.AsyncHTTP11Connection","httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of HTTP11ConnectionByteStream","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_closed":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http11.HTTP11ConnectionByteStream._closed","name":"_closed","setter_type":null,"type":"builtins.bool"}},"_connection":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http11.HTTP11ConnectionByteStream._connection","name":"_connection","setter_type":null,"type":"httpcore._async.http11.AsyncHTTP11Connection"}},"_request":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http11.HTTP11ConnectionByteStream._request","name":"_request","setter_type":null,"type":"httpcore._models.Request"}},"aclose":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http11.HTTP11ConnectionByteStream.aclose","name":"aclose","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.http11.HTTP11ConnectionByteStream"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"aclose of HTTP11ConnectionByteStream","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._async.http11.HTTP11ConnectionByteStream.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._async.http11.HTTP11ConnectionByteStream","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"HTTPConnectionState":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["enum.IntEnum"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._async.http11.HTTPConnectionState","name":"HTTPConnectionState","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_enum"],"fullname":"httpcore._async.http11.HTTPConnectionState","has_param_spec_type":false,"metaclass_type":"enum.EnumMeta","metadata":{},"module_name":"httpcore._async.http11","mro":["httpcore._async.http11.HTTPConnectionState","enum.IntEnum","builtins.int","enum.Enum","builtins.object"],"names":{".class":"SymbolTable","ACTIVE":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._async.http11.HTTPConnectionState.ACTIVE","name":"ACTIVE","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.int","value":1},"type_ref":"builtins.int"}}},"CLOSED":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._async.http11.HTTPConnectionState.CLOSED","name":"CLOSED","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.int","value":3},"type_ref":"builtins.int"}}},"IDLE":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._async.http11.HTTPConnectionState.IDLE","name":"IDLE","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.int","value":2},"type_ref":"builtins.int"}}},"NEW":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._async.http11.HTTPConnectionState.NEW","name":"NEW","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.int","value":0},"type_ref":"builtins.int"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._async.http11.HTTPConnectionState.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._async.http11.HTTPConnectionState","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"LocalProtocolError":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.LocalProtocolError","kind":"Gdef"},"Origin":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Origin","kind":"Gdef"},"RemoteProtocolError":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.RemoteProtocolError","kind":"Gdef"},"Request":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Request","kind":"Gdef"},"Response":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Response","kind":"Gdef"},"Trace":{".class":"SymbolTableNode","cross_ref":"httpcore._trace.Trace","kind":"Gdef"},"WriteError":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.WriteError","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.http11.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.http11.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.http11.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.http11.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.http11.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.http11.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"enum":{".class":"SymbolTableNode","cross_ref":"enum","kind":"Gdef"},"h11":{".class":"SymbolTableNode","cross_ref":"h11","kind":"Gdef"},"logger":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._async.http11.logger","name":"logger","setter_type":null,"type":"logging.Logger"}},"logging":{".class":"SymbolTableNode","cross_ref":"logging","kind":"Gdef"},"map_exceptions":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.map_exceptions","kind":"Gdef"},"ssl":{".class":"SymbolTableNode","cross_ref":"ssl","kind":"Gdef"},"time":{".class":"SymbolTableNode","cross_ref":"time","kind":"Gdef"},"types":{".class":"SymbolTableNode","cross_ref":"types","kind":"Gdef"},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_async/http11.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/http11.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/http11.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..b2959ba76f5022ba7b9d205ae90d7ec874de43f9 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/http11.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[12,23,13,20,21,22,1,3,4,5,6,7,8,10,1,1,1,1,1,1,1,1,1],"dep_prios":[5,5,5,5,5,5,5,10,10,10,10,10,10,10,5,30,30,30,30,30,30,30,30],"dependencies":["httpcore._backends.base","httpcore._async.interfaces","httpcore._exceptions","httpcore._models","httpcore._synchronization","httpcore._trace","__future__","enum","logging","ssl","time","types","typing","h11","builtins","_frozen_importlib","_ssl","abc","h11._connection","h11._events","h11._state","h11._util","httpcore._backends"],"hash":"2c731e13c1da38424fbad9557547ae088bc1b297","id":"httpcore._async.http11","ignore_all":true,"interface_hash":"3152288d3a6c311a5f02b4680746e1faca5cd325","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_async/http11.py","plugin_data":null,"size":13880,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/http2.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/http2.data.json new file mode 100644 index 0000000000000000000000000000000000000000..8b7ff83b8ccf396e4718c70f14b6ef92d924f0cb --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/http2.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"httpcore._async.http2","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","AsyncConnectionInterface":{".class":"SymbolTableNode","cross_ref":"httpcore._async.interfaces.AsyncConnectionInterface","kind":"Gdef"},"AsyncHTTP2Connection":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["httpcore._async.interfaces.AsyncConnectionInterface"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._async.http2.AsyncHTTP2Connection","name":"AsyncHTTP2Connection","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._async.http2.AsyncHTTP2Connection","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._async.http2","mro":["httpcore._async.http2.AsyncHTTP2Connection","httpcore._async.interfaces.AsyncConnectionInterface","httpcore._async.interfaces.AsyncRequestInterface","builtins.object"],"names":{".class":"SymbolTable","CONFIG":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection.CONFIG","name":"CONFIG","setter_type":null,"type":{".class":"AnyType","missing_import_name":"httpcore._async.http2.h2","source_any":{".class":"AnyType","missing_import_name":"httpcore._async.http2.h2","source_any":null,"type_of_any":3},"type_of_any":7}}},"READ_NUM_BYTES":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection.READ_NUM_BYTES","name":"READ_NUM_BYTES","setter_type":null,"type":"builtins.int"}},"__aenter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection.__aenter__","name":"__aenter__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.http2.AsyncHTTP2Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__aenter__ of AsyncHTTP2Connection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"httpcore._async.http2.AsyncHTTP2Connection"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__aexit__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","exc_type","exc_value","traceback"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection.__aexit__","name":"__aexit__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","exc_type","exc_value","traceback"],"arg_types":["httpcore._async.http2.AsyncHTTP2Connection",{".class":"UnionType","items":[{".class":"TypeType","item":"builtins.BaseException"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.BaseException",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["types.TracebackType",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__aexit__ of AsyncHTTP2Connection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","origin","stream","keepalive_expiry"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","origin","stream","keepalive_expiry"],"arg_types":["httpcore._async.http2.AsyncHTTP2Connection","httpcore._models.Origin","httpcore._backends.base.AsyncNetworkStream",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of AsyncHTTP2Connection","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection.__repr__","name":"__repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["httpcore._async.http2.AsyncHTTP2Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr__ of AsyncHTTP2Connection","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_connection_error":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection._connection_error","name":"_connection_error","setter_type":null,"type":"builtins.bool"}},"_connection_terminated":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection._connection_terminated","name":"_connection_terminated","setter_type":null,"type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"httpcore._async.http2.h2","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_events":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection._events","name":"_events","setter_type":null,"type":{".class":"Instance","args":["builtins.int",{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"httpcore._async.http2.h2","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"httpcore._async.http2.h2","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"httpcore._async.http2.h2","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"httpcore._async.http2.h2","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_expire_at":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection._expire_at","name":"_expire_at","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_h2_state":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection._h2_state","name":"_h2_state","setter_type":null,"type":{".class":"AnyType","missing_import_name":"httpcore._async.http2.h2","source_any":{".class":"AnyType","missing_import_name":"httpcore._async.http2.h2","source_any":null,"type_of_any":3},"type_of_any":7}}},"_init_lock":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection._init_lock","name":"_init_lock","setter_type":null,"type":"httpcore._synchronization.AsyncLock"}},"_keepalive_expiry":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection._keepalive_expiry","name":"_keepalive_expiry","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_max_streams":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection._max_streams","name":"_max_streams","setter_type":null,"type":"builtins.int"}},"_max_streams_semaphore":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection._max_streams_semaphore","name":"_max_streams_semaphore","setter_type":null,"type":"httpcore._synchronization.AsyncSemaphore"}},"_network_stream":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection._network_stream","name":"_network_stream","setter_type":null,"type":"httpcore._backends.base.AsyncNetworkStream"}},"_origin":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection._origin","name":"_origin","setter_type":null,"type":"httpcore._models.Origin"}},"_read_exception":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection._read_exception","name":"_read_exception","setter_type":null,"type":{".class":"UnionType","items":["builtins.Exception",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_read_incoming_data":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection._read_incoming_data","name":"_read_incoming_data","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["httpcore._async.http2.AsyncHTTP2Connection","httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_read_incoming_data of AsyncHTTP2Connection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"httpcore._async.http2.h2","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_read_lock":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection._read_lock","name":"_read_lock","setter_type":null,"type":"httpcore._synchronization.AsyncLock"}},"_receive_events":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","request","stream_id"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection._receive_events","name":"_receive_events","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","request","stream_id"],"arg_types":["httpcore._async.http2.AsyncHTTP2Connection","httpcore._models.Request",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_receive_events of AsyncHTTP2Connection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_receive_remote_settings_change":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","event"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection._receive_remote_settings_change","name":"_receive_remote_settings_change","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","event"],"arg_types":["httpcore._async.http2.AsyncHTTP2Connection",{".class":"AnyType","missing_import_name":"httpcore._async.http2.h2","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_receive_remote_settings_change of AsyncHTTP2Connection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_receive_response":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","request","stream_id"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection._receive_response","name":"_receive_response","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","request","stream_id"],"arg_types":["httpcore._async.http2.AsyncHTTP2Connection","httpcore._models.Request","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_receive_response of AsyncHTTP2Connection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"TupleType","implicit":false,"items":["builtins.int",{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.bytes","builtins.bytes"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"builtins.list"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_receive_response_body":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","request","stream_id"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_generator","is_coroutine","is_async_generator","is_trivial_self"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection._receive_response_body","name":"_receive_response_body","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","request","stream_id"],"arg_types":["httpcore._async.http2.AsyncHTTP2Connection","httpcore._models.Request","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_receive_response_body of AsyncHTTP2Connection","ret_type":{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.AsyncIterator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_receive_stream_event":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","request","stream_id"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection._receive_stream_event","name":"_receive_stream_event","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","request","stream_id"],"arg_types":["httpcore._async.http2.AsyncHTTP2Connection","httpcore._models.Request","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_receive_stream_event of AsyncHTTP2Connection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"httpcore._async.http2.h2","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"httpcore._async.http2.h2","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"httpcore._async.http2.h2","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_request_count":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection._request_count","name":"_request_count","setter_type":null,"type":"builtins.int"}},"_response_closed":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","stream_id"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection._response_closed","name":"_response_closed","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","stream_id"],"arg_types":["httpcore._async.http2.AsyncHTTP2Connection","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_response_closed of AsyncHTTP2Connection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_send_connection_init":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection._send_connection_init","name":"_send_connection_init","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["httpcore._async.http2.AsyncHTTP2Connection","httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_send_connection_init of AsyncHTTP2Connection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_send_end_stream":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","request","stream_id"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection._send_end_stream","name":"_send_end_stream","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","request","stream_id"],"arg_types":["httpcore._async.http2.AsyncHTTP2Connection","httpcore._models.Request","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_send_end_stream of AsyncHTTP2Connection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_send_request_body":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","request","stream_id"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection._send_request_body","name":"_send_request_body","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","request","stream_id"],"arg_types":["httpcore._async.http2.AsyncHTTP2Connection","httpcore._models.Request","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_send_request_body of AsyncHTTP2Connection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_send_request_headers":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","request","stream_id"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection._send_request_headers","name":"_send_request_headers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","request","stream_id"],"arg_types":["httpcore._async.http2.AsyncHTTP2Connection","httpcore._models.Request","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_send_request_headers of AsyncHTTP2Connection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_send_stream_data":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","request","stream_id","data"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection._send_stream_data","name":"_send_stream_data","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","request","stream_id","data"],"arg_types":["httpcore._async.http2.AsyncHTTP2Connection","httpcore._models.Request","builtins.int","builtins.bytes"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_send_stream_data of AsyncHTTP2Connection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_sent_connection_init":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection._sent_connection_init","name":"_sent_connection_init","setter_type":null,"type":"builtins.bool"}},"_state":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection._state","name":"_state","setter_type":null,"type":"httpcore._async.http2.HTTPConnectionState"}},"_state_lock":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection._state_lock","name":"_state_lock","setter_type":null,"type":"httpcore._synchronization.AsyncLock"}},"_used_all_stream_ids":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection._used_all_stream_ids","name":"_used_all_stream_ids","setter_type":null,"type":"builtins.bool"}},"_wait_for_outgoing_flow":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","request","stream_id"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection._wait_for_outgoing_flow","name":"_wait_for_outgoing_flow","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","request","stream_id"],"arg_types":["httpcore._async.http2.AsyncHTTP2Connection","httpcore._models.Request","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_wait_for_outgoing_flow of AsyncHTTP2Connection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"builtins.int"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_write_exception":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection._write_exception","name":"_write_exception","setter_type":null,"type":{".class":"UnionType","items":["builtins.Exception",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_write_lock":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection._write_lock","name":"_write_lock","setter_type":null,"type":"httpcore._synchronization.AsyncLock"}},"_write_outgoing_data":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection._write_outgoing_data","name":"_write_outgoing_data","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["httpcore._async.http2.AsyncHTTP2Connection","httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_write_outgoing_data of AsyncHTTP2Connection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"aclose":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection.aclose","name":"aclose","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.http2.AsyncHTTP2Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"aclose of AsyncHTTP2Connection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"can_handle_request":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","origin"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection.can_handle_request","name":"can_handle_request","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","origin"],"arg_types":["httpcore._async.http2.AsyncHTTP2Connection","httpcore._models.Origin"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"can_handle_request of AsyncHTTP2Connection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"handle_async_request":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection.handle_async_request","name":"handle_async_request","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["httpcore._async.http2.AsyncHTTP2Connection","httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"handle_async_request of AsyncHTTP2Connection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"httpcore._models.Response"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"has_expired":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection.has_expired","name":"has_expired","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.http2.AsyncHTTP2Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"has_expired of AsyncHTTP2Connection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"info":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection.info","name":"info","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.http2.AsyncHTTP2Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"info of AsyncHTTP2Connection","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_available":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection.is_available","name":"is_available","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.http2.AsyncHTTP2Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_available of AsyncHTTP2Connection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_closed":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection.is_closed","name":"is_closed","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.http2.AsyncHTTP2Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_closed of AsyncHTTP2Connection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_idle":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http2.AsyncHTTP2Connection.is_idle","name":"is_idle","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.http2.AsyncHTTP2Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_idle of AsyncHTTP2Connection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._async.http2.AsyncHTTP2Connection.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._async.http2.AsyncHTTP2Connection","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"AsyncLock":{".class":"SymbolTableNode","cross_ref":"httpcore._synchronization.AsyncLock","kind":"Gdef"},"AsyncNetworkStream":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.AsyncNetworkStream","kind":"Gdef"},"AsyncSemaphore":{".class":"SymbolTableNode","cross_ref":"httpcore._synchronization.AsyncSemaphore","kind":"Gdef"},"AsyncShieldCancellation":{".class":"SymbolTableNode","cross_ref":"httpcore._synchronization.AsyncShieldCancellation","kind":"Gdef"},"ConnectionNotAvailable":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.ConnectionNotAvailable","kind":"Gdef"},"HTTP2ConnectionByteStream":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._async.http2.HTTP2ConnectionByteStream","name":"HTTP2ConnectionByteStream","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._async.http2.HTTP2ConnectionByteStream","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._async.http2","mro":["httpcore._async.http2.HTTP2ConnectionByteStream","builtins.object"],"names":{".class":"SymbolTable","__aiter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_generator","is_coroutine","is_async_generator","is_trivial_self"],"fullname":"httpcore._async.http2.HTTP2ConnectionByteStream.__aiter__","name":"__aiter__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.http2.HTTP2ConnectionByteStream"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__aiter__ of HTTP2ConnectionByteStream","ret_type":{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.AsyncIterator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","connection","request","stream_id"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http2.HTTP2ConnectionByteStream.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","connection","request","stream_id"],"arg_types":["httpcore._async.http2.HTTP2ConnectionByteStream","httpcore._async.http2.AsyncHTTP2Connection","httpcore._models.Request","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of HTTP2ConnectionByteStream","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_closed":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http2.HTTP2ConnectionByteStream._closed","name":"_closed","setter_type":null,"type":"builtins.bool"}},"_connection":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http2.HTTP2ConnectionByteStream._connection","name":"_connection","setter_type":null,"type":"httpcore._async.http2.AsyncHTTP2Connection"}},"_request":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http2.HTTP2ConnectionByteStream._request","name":"_request","setter_type":null,"type":"httpcore._models.Request"}},"_stream_id":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http2.HTTP2ConnectionByteStream._stream_id","name":"_stream_id","setter_type":null,"type":"builtins.int"}},"aclose":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http2.HTTP2ConnectionByteStream.aclose","name":"aclose","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.http2.HTTP2ConnectionByteStream"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"aclose of HTTP2ConnectionByteStream","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._async.http2.HTTP2ConnectionByteStream.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._async.http2.HTTP2ConnectionByteStream","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"HTTPConnectionState":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["enum.IntEnum"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._async.http2.HTTPConnectionState","name":"HTTPConnectionState","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_enum"],"fullname":"httpcore._async.http2.HTTPConnectionState","has_param_spec_type":false,"metaclass_type":"enum.EnumMeta","metadata":{},"module_name":"httpcore._async.http2","mro":["httpcore._async.http2.HTTPConnectionState","enum.IntEnum","builtins.int","enum.Enum","builtins.object"],"names":{".class":"SymbolTable","ACTIVE":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._async.http2.HTTPConnectionState.ACTIVE","name":"ACTIVE","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.int","value":1},"type_ref":"builtins.int"}}},"CLOSED":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._async.http2.HTTPConnectionState.CLOSED","name":"CLOSED","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.int","value":3},"type_ref":"builtins.int"}}},"IDLE":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._async.http2.HTTPConnectionState.IDLE","name":"IDLE","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.int","value":2},"type_ref":"builtins.int"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._async.http2.HTTPConnectionState.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._async.http2.HTTPConnectionState","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"LocalProtocolError":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.LocalProtocolError","kind":"Gdef"},"Origin":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Origin","kind":"Gdef"},"RemoteProtocolError":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.RemoteProtocolError","kind":"Gdef"},"Request":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Request","kind":"Gdef"},"Response":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Response","kind":"Gdef"},"Trace":{".class":"SymbolTableNode","cross_ref":"httpcore._trace.Trace","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.http2.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.http2.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.http2.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.http2.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.http2.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.http2.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"enum":{".class":"SymbolTableNode","cross_ref":"enum","kind":"Gdef"},"h2":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"httpcore._async.http2.h2","name":"h2","setter_type":null,"type":{".class":"AnyType","missing_import_name":"httpcore._async.http2.h2","source_any":null,"type_of_any":3}}},"has_body_headers":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["request"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"httpcore._async.http2.has_body_headers","name":"has_body_headers","original_first_arg":"request","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["request"],"arg_types":["httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"has_body_headers","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"logger":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._async.http2.logger","name":"logger","setter_type":null,"type":"logging.Logger"}},"logging":{".class":"SymbolTableNode","cross_ref":"logging","kind":"Gdef"},"time":{".class":"SymbolTableNode","cross_ref":"time","kind":"Gdef"},"types":{".class":"SymbolTableNode","cross_ref":"types","kind":"Gdef"},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_async/http2.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/http2.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/http2.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..21a29cfa13ddb507dfedd6e681c2484ca6b17a44 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/http2.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[15,24,16,21,22,23,1,3,4,5,6,7,1,1,1,1,9,10,11,12,13,9],"dep_prios":[5,5,5,5,5,5,5,10,10,10,10,10,5,30,30,30,10,10,10,10,10,20],"dependencies":["httpcore._backends.base","httpcore._async.interfaces","httpcore._exceptions","httpcore._models","httpcore._synchronization","httpcore._trace","__future__","enum","logging","time","types","typing","builtins","_frozen_importlib","abc","httpcore._backends"],"hash":"2c93ee1ba220aa1692d3ffd3720ffbafd0a00656","id":"httpcore._async.http2","ignore_all":true,"interface_hash":"cc4bcae4fd96be228b5f860098c35919ac9ce73a","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_async/http2.py","plugin_data":null,"size":23936,"suppressed":["h2.config","h2.connection","h2.events","h2.exceptions","h2.settings","h2"],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/http_proxy.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/http_proxy.data.json new file mode 100644 index 0000000000000000000000000000000000000000..34a77f98df95d8e90ebd301b6640d1505bc53cbd --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/http_proxy.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"httpcore._async.http_proxy","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","AsyncConnectionInterface":{".class":"SymbolTableNode","cross_ref":"httpcore._async.interfaces.AsyncConnectionInterface","kind":"Gdef"},"AsyncConnectionPool":{".class":"SymbolTableNode","cross_ref":"httpcore._async.connection_pool.AsyncConnectionPool","kind":"Gdef"},"AsyncForwardHTTPConnection":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["httpcore._async.interfaces.AsyncConnectionInterface"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._async.http_proxy.AsyncForwardHTTPConnection","name":"AsyncForwardHTTPConnection","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._async.http_proxy.AsyncForwardHTTPConnection","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._async.http_proxy","mro":["httpcore._async.http_proxy.AsyncForwardHTTPConnection","httpcore._async.interfaces.AsyncConnectionInterface","httpcore._async.interfaces.AsyncRequestInterface","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1,1,1],"arg_names":["self","proxy_origin","remote_origin","proxy_headers","keepalive_expiry","network_backend","socket_options","proxy_ssl_context"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http_proxy.AsyncForwardHTTPConnection.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1,1],"arg_names":["self","proxy_origin","remote_origin","proxy_headers","keepalive_expiry","network_backend","socket_options","proxy_ssl_context"],"arg_types":["httpcore._async.http_proxy.AsyncForwardHTTPConnection","httpcore._models.Origin","httpcore._models.Origin",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._async.http_proxy.HeadersAsMapping"},{".class":"TypeAliasType","args":[],"type_ref":"httpcore._async.http_proxy.HeadersAsSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["httpcore._backends.base.AsyncNetworkBackend",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._backends.base.SOCKET_OPTION"}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of AsyncForwardHTTPConnection","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http_proxy.AsyncForwardHTTPConnection.__repr__","name":"__repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["httpcore._async.http_proxy.AsyncForwardHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr__ of AsyncForwardHTTPConnection","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_connection":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http_proxy.AsyncForwardHTTPConnection._connection","name":"_connection","setter_type":null,"type":"httpcore._async.connection.AsyncHTTPConnection"}},"_proxy_headers":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http_proxy.AsyncForwardHTTPConnection._proxy_headers","name":"_proxy_headers","setter_type":null,"type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.bytes","builtins.bytes"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"builtins.list"}}},"_proxy_origin":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http_proxy.AsyncForwardHTTPConnection._proxy_origin","name":"_proxy_origin","setter_type":null,"type":"httpcore._models.Origin"}},"_remote_origin":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http_proxy.AsyncForwardHTTPConnection._remote_origin","name":"_remote_origin","setter_type":null,"type":"httpcore._models.Origin"}},"aclose":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http_proxy.AsyncForwardHTTPConnection.aclose","name":"aclose","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.http_proxy.AsyncForwardHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"aclose of AsyncForwardHTTPConnection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"can_handle_request":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","origin"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http_proxy.AsyncForwardHTTPConnection.can_handle_request","name":"can_handle_request","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","origin"],"arg_types":["httpcore._async.http_proxy.AsyncForwardHTTPConnection","httpcore._models.Origin"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"can_handle_request of AsyncForwardHTTPConnection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"handle_async_request":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http_proxy.AsyncForwardHTTPConnection.handle_async_request","name":"handle_async_request","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["httpcore._async.http_proxy.AsyncForwardHTTPConnection","httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"handle_async_request of AsyncForwardHTTPConnection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"httpcore._models.Response"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"has_expired":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http_proxy.AsyncForwardHTTPConnection.has_expired","name":"has_expired","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.http_proxy.AsyncForwardHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"has_expired of AsyncForwardHTTPConnection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"info":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http_proxy.AsyncForwardHTTPConnection.info","name":"info","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.http_proxy.AsyncForwardHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"info of AsyncForwardHTTPConnection","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_available":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http_proxy.AsyncForwardHTTPConnection.is_available","name":"is_available","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.http_proxy.AsyncForwardHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_available of AsyncForwardHTTPConnection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_closed":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http_proxy.AsyncForwardHTTPConnection.is_closed","name":"is_closed","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.http_proxy.AsyncForwardHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_closed of AsyncForwardHTTPConnection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_idle":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http_proxy.AsyncForwardHTTPConnection.is_idle","name":"is_idle","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.http_proxy.AsyncForwardHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_idle of AsyncForwardHTTPConnection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._async.http_proxy.AsyncForwardHTTPConnection.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._async.http_proxy.AsyncForwardHTTPConnection","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"AsyncHTTP11Connection":{".class":"SymbolTableNode","cross_ref":"httpcore._async.http11.AsyncHTTP11Connection","kind":"Gdef"},"AsyncHTTPConnection":{".class":"SymbolTableNode","cross_ref":"httpcore._async.connection.AsyncHTTPConnection","kind":"Gdef"},"AsyncHTTPProxy":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["httpcore._async.connection_pool.AsyncConnectionPool"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._async.http_proxy.AsyncHTTPProxy","name":"AsyncHTTPProxy","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._async.http_proxy.AsyncHTTPProxy","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._async.http_proxy","mro":["httpcore._async.http_proxy.AsyncHTTPProxy","httpcore._async.connection_pool.AsyncConnectionPool","httpcore._async.interfaces.AsyncRequestInterface","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1],"arg_names":["self","proxy_url","proxy_auth","proxy_headers","ssl_context","proxy_ssl_context","max_connections","max_keepalive_connections","keepalive_expiry","http1","http2","retries","local_address","uds","network_backend","socket_options"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http_proxy.AsyncHTTPProxy.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1],"arg_names":["self","proxy_url","proxy_auth","proxy_headers","ssl_context","proxy_ssl_context","max_connections","max_keepalive_connections","keepalive_expiry","http1","http2","retries","local_address","uds","network_backend","socket_options"],"arg_types":["httpcore._async.http_proxy.AsyncHTTPProxy",{".class":"UnionType","items":["httpcore._models.URL","builtins.bytes","builtins.str"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.bytes","builtins.str"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bytes","builtins.str"],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._async.http_proxy.HeadersAsMapping"},{".class":"TypeAliasType","args":[],"type_ref":"httpcore._async.http_proxy.HeadersAsSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool","builtins.int",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["httpcore._backends.base.AsyncNetworkBackend",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._backends.base.SOCKET_OPTION"}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of AsyncHTTPProxy","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_proxy_headers":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http_proxy.AsyncHTTPProxy._proxy_headers","name":"_proxy_headers","setter_type":null,"type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.bytes","builtins.bytes"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"builtins.list"}}},"_proxy_ssl_context":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http_proxy.AsyncHTTPProxy._proxy_ssl_context","name":"_proxy_ssl_context","setter_type":null,"type":{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_proxy_url":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http_proxy.AsyncHTTPProxy._proxy_url","name":"_proxy_url","setter_type":null,"type":"httpcore._models.URL"}},"create_connection":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","origin"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http_proxy.AsyncHTTPProxy.create_connection","name":"create_connection","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","origin"],"arg_types":["httpcore._async.http_proxy.AsyncHTTPProxy","httpcore._models.Origin"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"create_connection of AsyncHTTPProxy","ret_type":"httpcore._async.interfaces.AsyncConnectionInterface","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._async.http_proxy.AsyncHTTPProxy.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._async.http_proxy.AsyncHTTPProxy","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"AsyncLock":{".class":"SymbolTableNode","cross_ref":"httpcore._synchronization.AsyncLock","kind":"Gdef"},"AsyncNetworkBackend":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.AsyncNetworkBackend","kind":"Gdef"},"AsyncTunnelHTTPConnection":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["httpcore._async.interfaces.AsyncConnectionInterface"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._async.http_proxy.AsyncTunnelHTTPConnection","name":"AsyncTunnelHTTPConnection","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._async.http_proxy.AsyncTunnelHTTPConnection","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._async.http_proxy","mro":["httpcore._async.http_proxy.AsyncTunnelHTTPConnection","httpcore._async.interfaces.AsyncConnectionInterface","httpcore._async.interfaces.AsyncRequestInterface","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1,1,1,1,1,1],"arg_names":["self","proxy_origin","remote_origin","ssl_context","proxy_ssl_context","proxy_headers","keepalive_expiry","http1","http2","network_backend","socket_options"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http_proxy.AsyncTunnelHTTPConnection.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1,1,1,1,1],"arg_names":["self","proxy_origin","remote_origin","ssl_context","proxy_ssl_context","proxy_headers","keepalive_expiry","http1","http2","network_backend","socket_options"],"arg_types":["httpcore._async.http_proxy.AsyncTunnelHTTPConnection","httpcore._models.Origin","httpcore._models.Origin",{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.bytes","builtins.bytes"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool",{".class":"UnionType","items":["httpcore._backends.base.AsyncNetworkBackend",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._backends.base.SOCKET_OPTION"}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of AsyncTunnelHTTPConnection","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http_proxy.AsyncTunnelHTTPConnection.__repr__","name":"__repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["httpcore._async.http_proxy.AsyncTunnelHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr__ of AsyncTunnelHTTPConnection","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_connect_lock":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http_proxy.AsyncTunnelHTTPConnection._connect_lock","name":"_connect_lock","setter_type":null,"type":"httpcore._synchronization.AsyncLock"}},"_connected":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http_proxy.AsyncTunnelHTTPConnection._connected","name":"_connected","setter_type":null,"type":"builtins.bool"}},"_connection":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._async.http_proxy.AsyncTunnelHTTPConnection._connection","name":"_connection","setter_type":null,"type":"httpcore._async.interfaces.AsyncConnectionInterface"}},"_http1":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http_proxy.AsyncTunnelHTTPConnection._http1","name":"_http1","setter_type":null,"type":"builtins.bool"}},"_http2":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http_proxy.AsyncTunnelHTTPConnection._http2","name":"_http2","setter_type":null,"type":"builtins.bool"}},"_keepalive_expiry":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http_proxy.AsyncTunnelHTTPConnection._keepalive_expiry","name":"_keepalive_expiry","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_proxy_headers":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http_proxy.AsyncTunnelHTTPConnection._proxy_headers","name":"_proxy_headers","setter_type":null,"type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.bytes","builtins.bytes"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"builtins.list"}}},"_proxy_origin":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http_proxy.AsyncTunnelHTTPConnection._proxy_origin","name":"_proxy_origin","setter_type":null,"type":"httpcore._models.Origin"}},"_proxy_ssl_context":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http_proxy.AsyncTunnelHTTPConnection._proxy_ssl_context","name":"_proxy_ssl_context","setter_type":null,"type":{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_remote_origin":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http_proxy.AsyncTunnelHTTPConnection._remote_origin","name":"_remote_origin","setter_type":null,"type":"httpcore._models.Origin"}},"_ssl_context":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.http_proxy.AsyncTunnelHTTPConnection._ssl_context","name":"_ssl_context","setter_type":null,"type":{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"aclose":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http_proxy.AsyncTunnelHTTPConnection.aclose","name":"aclose","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.http_proxy.AsyncTunnelHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"aclose of AsyncTunnelHTTPConnection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"can_handle_request":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","origin"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http_proxy.AsyncTunnelHTTPConnection.can_handle_request","name":"can_handle_request","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","origin"],"arg_types":["httpcore._async.http_proxy.AsyncTunnelHTTPConnection","httpcore._models.Origin"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"can_handle_request of AsyncTunnelHTTPConnection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"handle_async_request":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.http_proxy.AsyncTunnelHTTPConnection.handle_async_request","name":"handle_async_request","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["httpcore._async.http_proxy.AsyncTunnelHTTPConnection","httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"handle_async_request of AsyncTunnelHTTPConnection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"httpcore._models.Response"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"has_expired":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http_proxy.AsyncTunnelHTTPConnection.has_expired","name":"has_expired","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.http_proxy.AsyncTunnelHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"has_expired of AsyncTunnelHTTPConnection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"info":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http_proxy.AsyncTunnelHTTPConnection.info","name":"info","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.http_proxy.AsyncTunnelHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"info of AsyncTunnelHTTPConnection","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_available":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http_proxy.AsyncTunnelHTTPConnection.is_available","name":"is_available","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.http_proxy.AsyncTunnelHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_available of AsyncTunnelHTTPConnection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_closed":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http_proxy.AsyncTunnelHTTPConnection.is_closed","name":"is_closed","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.http_proxy.AsyncTunnelHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_closed of AsyncTunnelHTTPConnection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_idle":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.http_proxy.AsyncTunnelHTTPConnection.is_idle","name":"is_idle","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.http_proxy.AsyncTunnelHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_idle of AsyncTunnelHTTPConnection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._async.http_proxy.AsyncTunnelHTTPConnection.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._async.http_proxy.AsyncTunnelHTTPConnection","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ByteOrStr":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"httpcore._async.http_proxy.ByteOrStr","line":27,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["builtins.bytes","builtins.str"],"uses_pep604_syntax":false}}},"HeadersAsMapping":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"httpcore._async.http_proxy.HeadersAsMapping","line":29,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._async.http_proxy.ByteOrStr"},{".class":"TypeAliasType","args":[],"type_ref":"httpcore._async.http_proxy.ByteOrStr"}],"extra_attrs":null,"type_ref":"typing.Mapping"}}},"HeadersAsSequence":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"httpcore._async.http_proxy.HeadersAsSequence","line":28,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._async.http_proxy.ByteOrStr"},{".class":"TypeAliasType","args":[],"type_ref":"httpcore._async.http_proxy.ByteOrStr"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"typing.Sequence"}}},"Origin":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Origin","kind":"Gdef"},"ProxyError":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.ProxyError","kind":"Gdef"},"Request":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Request","kind":"Gdef"},"Response":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Response","kind":"Gdef"},"SOCKET_OPTION":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.SOCKET_OPTION","kind":"Gdef"},"Trace":{".class":"SymbolTableNode","cross_ref":"httpcore._trace.Trace","kind":"Gdef"},"URL":{".class":"SymbolTableNode","cross_ref":"httpcore._models.URL","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.http_proxy.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.http_proxy.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.http_proxy.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.http_proxy.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.http_proxy.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.http_proxy.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"base64":{".class":"SymbolTableNode","cross_ref":"base64","kind":"Gdef"},"default_ssl_context":{".class":"SymbolTableNode","cross_ref":"httpcore._ssl.default_ssl_context","kind":"Gdef"},"enforce_bytes":{".class":"SymbolTableNode","cross_ref":"httpcore._models.enforce_bytes","kind":"Gdef"},"enforce_headers":{".class":"SymbolTableNode","cross_ref":"httpcore._models.enforce_headers","kind":"Gdef"},"enforce_url":{".class":"SymbolTableNode","cross_ref":"httpcore._models.enforce_url","kind":"Gdef"},"logger":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._async.http_proxy.logger","name":"logger","setter_type":null,"type":"logging.Logger"}},"logging":{".class":"SymbolTableNode","cross_ref":"logging","kind":"Gdef"},"merge_headers":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1,1],"arg_names":["default_headers","override_headers"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"httpcore._async.http_proxy.merge_headers","name":"merge_headers","original_first_arg":"default_headers","type":{".class":"CallableType","arg_kinds":[1,1],"arg_names":["default_headers","override_headers"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.bytes","builtins.bytes"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.bytes","builtins.bytes"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"merge_headers","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.bytes","builtins.bytes"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"ssl":{".class":"SymbolTableNode","cross_ref":"ssl","kind":"Gdef"},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_async/http_proxy.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/http_proxy.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/http_proxy.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..5dd14bd7640ec56b6446c53f2c39031539b45854 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/http_proxy.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[8,22,23,24,25,328,9,10,19,20,21,1,3,4,5,6,1,1,1,1,1,1],"dep_prios":[5,5,5,5,5,20,5,5,5,5,5,5,10,10,10,10,5,30,30,30,30,30],"dependencies":["httpcore._backends.base","httpcore._async.connection","httpcore._async.connection_pool","httpcore._async.http11","httpcore._async.interfaces","httpcore._async.http2","httpcore._exceptions","httpcore._models","httpcore._ssl","httpcore._synchronization","httpcore._trace","__future__","base64","logging","ssl","typing","builtins","_frozen_importlib","_ssl","abc","httpcore._backends","typing_extensions"],"hash":"3136a1456678fce0a10ce6949fd737e5cbb0c2f2","id":"httpcore._async.http_proxy","ignore_all":true,"interface_hash":"60efa5122729bd47390e851681983876b4e5cc80","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_async/http_proxy.py","plugin_data":null,"size":14701,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/interfaces.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/interfaces.data.json new file mode 100644 index 0000000000000000000000000000000000000000..520027356b3b3221da3cbdd109030e7000026e26 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/interfaces.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"httpcore._async.interfaces","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","AsyncConnectionInterface":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["httpcore._async.interfaces.AsyncRequestInterface"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._async.interfaces.AsyncConnectionInterface","name":"AsyncConnectionInterface","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._async.interfaces.AsyncConnectionInterface","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._async.interfaces","mro":["httpcore._async.interfaces.AsyncConnectionInterface","httpcore._async.interfaces.AsyncRequestInterface","builtins.object"],"names":{".class":"SymbolTable","aclose":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.interfaces.AsyncConnectionInterface.aclose","name":"aclose","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.interfaces.AsyncConnectionInterface"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"aclose of AsyncConnectionInterface","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"can_handle_request":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","origin"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.interfaces.AsyncConnectionInterface.can_handle_request","name":"can_handle_request","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","origin"],"arg_types":["httpcore._async.interfaces.AsyncConnectionInterface","httpcore._models.Origin"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"can_handle_request of AsyncConnectionInterface","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"has_expired":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.interfaces.AsyncConnectionInterface.has_expired","name":"has_expired","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.interfaces.AsyncConnectionInterface"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"has_expired of AsyncConnectionInterface","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"info":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.interfaces.AsyncConnectionInterface.info","name":"info","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.interfaces.AsyncConnectionInterface"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"info of AsyncConnectionInterface","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_available":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.interfaces.AsyncConnectionInterface.is_available","name":"is_available","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.interfaces.AsyncConnectionInterface"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_available of AsyncConnectionInterface","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_closed":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.interfaces.AsyncConnectionInterface.is_closed","name":"is_closed","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.interfaces.AsyncConnectionInterface"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_closed of AsyncConnectionInterface","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_idle":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.interfaces.AsyncConnectionInterface.is_idle","name":"is_idle","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.interfaces.AsyncConnectionInterface"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_idle of AsyncConnectionInterface","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._async.interfaces.AsyncConnectionInterface.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._async.interfaces.AsyncConnectionInterface","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"AsyncRequestInterface":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._async.interfaces.AsyncRequestInterface","name":"AsyncRequestInterface","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._async.interfaces.AsyncRequestInterface","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._async.interfaces","mro":["httpcore._async.interfaces.AsyncRequestInterface","builtins.object"],"names":{".class":"SymbolTable","handle_async_request":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.interfaces.AsyncRequestInterface.handle_async_request","name":"handle_async_request","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["httpcore._async.interfaces.AsyncRequestInterface","httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"handle_async_request of AsyncRequestInterface","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"httpcore._models.Response"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"request":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5,5,5],"arg_names":["self","method","url","headers","content","extensions"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.interfaces.AsyncRequestInterface.request","name":"request","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,5,5,5],"arg_names":["self","method","url","headers","content","extensions"],"arg_types":["httpcore._async.interfaces.AsyncRequestInterface",{".class":"UnionType","items":["builtins.bytes","builtins.str"],"uses_pep604_syntax":true},{".class":"UnionType","items":["httpcore._models.URL","builtins.bytes","builtins.str"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._models.HeaderTypes"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.AsyncIterator"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._models.Extensions"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"request of AsyncRequestInterface","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"httpcore._models.Response"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"stream":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5,5,5],"arg_names":["self","method","url","headers","content","extensions"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_generator","is_coroutine","is_async_generator","is_decorated","is_trivial_self"],"fullname":"httpcore._async.interfaces.AsyncRequestInterface.stream","name":"stream","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,5,5,5],"arg_names":["self","method","url","headers","content","extensions"],"arg_types":["httpcore._async.interfaces.AsyncRequestInterface",{".class":"UnionType","items":["builtins.bytes","builtins.str"],"uses_pep604_syntax":true},{".class":"UnionType","items":["httpcore._models.URL","builtins.bytes","builtins.str"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._models.HeaderTypes"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.AsyncIterator"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._models.Extensions"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"stream of AsyncRequestInterface","ret_type":{".class":"Instance","args":["httpcore._models.Response"],"extra_attrs":null,"type_ref":"typing.AsyncIterator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred"],"fullname":"httpcore._async.interfaces.AsyncRequestInterface.stream","name":"stream","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,5,5,5],"arg_names":["self","method","url","headers","content","extensions"],"arg_types":["httpcore._async.interfaces.AsyncRequestInterface",{".class":"UnionType","items":["builtins.bytes","builtins.str"],"uses_pep604_syntax":true},{".class":"UnionType","items":["httpcore._models.URL","builtins.bytes","builtins.str"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._models.HeaderTypes"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.AsyncIterator"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._models.Extensions"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"stream of AsyncRequestInterface","ret_type":{".class":"Instance","args":["httpcore._models.Response",{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._AsyncGeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._async.interfaces.AsyncRequestInterface.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._async.interfaces.AsyncRequestInterface","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Extensions":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Extensions","kind":"Gdef"},"HeaderTypes":{".class":"SymbolTableNode","cross_ref":"httpcore._models.HeaderTypes","kind":"Gdef"},"Origin":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Origin","kind":"Gdef"},"Request":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Request","kind":"Gdef"},"Response":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Response","kind":"Gdef"},"URL":{".class":"SymbolTableNode","cross_ref":"httpcore._models.URL","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.interfaces.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.interfaces.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.interfaces.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.interfaces.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.interfaces.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.interfaces.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"contextlib":{".class":"SymbolTableNode","cross_ref":"contextlib","kind":"Gdef"},"enforce_bytes":{".class":"SymbolTableNode","cross_ref":"httpcore._models.enforce_bytes","kind":"Gdef"},"enforce_headers":{".class":"SymbolTableNode","cross_ref":"httpcore._models.enforce_headers","kind":"Gdef"},"enforce_url":{".class":"SymbolTableNode","cross_ref":"httpcore._models.enforce_url","kind":"Gdef"},"include_request_headers":{".class":"SymbolTableNode","cross_ref":"httpcore._models.include_request_headers","kind":"Gdef"},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_async/interfaces.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/interfaces.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/interfaces.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..1f8c71afce9c56819d23e39e2b68dfe634e380ea --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/interfaces.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[6,1,3,4,1,1,1],"dep_prios":[5,5,10,10,5,30,30],"dependencies":["httpcore._models","__future__","contextlib","typing","builtins","_frozen_importlib","abc"],"hash":"da8932befdc5050e68951c78e6d5f75cf4d1455c","id":"httpcore._async.interfaces","ignore_all":true,"interface_hash":"a5750ab3656c328a5c6c1e371c19b21e130d6d2e","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_async/interfaces.py","plugin_data":null,"size":4455,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/socks_proxy.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/socks_proxy.data.json new file mode 100644 index 0000000000000000000000000000000000000000..b548278a3150f38650c6dcea7cd60f5f06a91313 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/socks_proxy.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"httpcore._async.socks_proxy","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","AUTH_METHODS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._async.socks_proxy.AUTH_METHODS","name":"AUTH_METHODS","setter_type":null,"type":{".class":"Instance","args":["builtins.bytes","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"AsyncConnectionInterface":{".class":"SymbolTableNode","cross_ref":"httpcore._async.interfaces.AsyncConnectionInterface","kind":"Gdef"},"AsyncConnectionPool":{".class":"SymbolTableNode","cross_ref":"httpcore._async.connection_pool.AsyncConnectionPool","kind":"Gdef"},"AsyncHTTP11Connection":{".class":"SymbolTableNode","cross_ref":"httpcore._async.http11.AsyncHTTP11Connection","kind":"Gdef"},"AsyncLock":{".class":"SymbolTableNode","cross_ref":"httpcore._synchronization.AsyncLock","kind":"Gdef"},"AsyncNetworkBackend":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.AsyncNetworkBackend","kind":"Gdef"},"AsyncNetworkStream":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.AsyncNetworkStream","kind":"Gdef"},"AsyncSOCKSProxy":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["httpcore._async.connection_pool.AsyncConnectionPool"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._async.socks_proxy.AsyncSOCKSProxy","name":"AsyncSOCKSProxy","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._async.socks_proxy.AsyncSOCKSProxy","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._async.socks_proxy","mro":["httpcore._async.socks_proxy.AsyncSOCKSProxy","httpcore._async.connection_pool.AsyncConnectionPool","httpcore._async.interfaces.AsyncRequestInterface","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,1,1,1,1],"arg_names":["self","proxy_url","proxy_auth","ssl_context","max_connections","max_keepalive_connections","keepalive_expiry","http1","http2","retries","network_backend"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.socks_proxy.AsyncSOCKSProxy.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1,1,1,1],"arg_names":["self","proxy_url","proxy_auth","ssl_context","max_connections","max_keepalive_connections","keepalive_expiry","http1","http2","retries","network_backend"],"arg_types":["httpcore._async.socks_proxy.AsyncSOCKSProxy",{".class":"UnionType","items":["httpcore._models.URL","builtins.bytes","builtins.str"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.bytes","builtins.str"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bytes","builtins.str"],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool","builtins.int",{".class":"UnionType","items":["httpcore._backends.base.AsyncNetworkBackend",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of AsyncSOCKSProxy","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_proxy_auth":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._async.socks_proxy.AsyncSOCKSProxy._proxy_auth","name":"_proxy_auth","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TupleType","implicit":false,"items":["builtins.bytes","builtins.bytes"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_proxy_url":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.socks_proxy.AsyncSOCKSProxy._proxy_url","name":"_proxy_url","setter_type":null,"type":"httpcore._models.URL"}},"create_connection":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","origin"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.socks_proxy.AsyncSOCKSProxy.create_connection","name":"create_connection","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","origin"],"arg_types":["httpcore._async.socks_proxy.AsyncSOCKSProxy","httpcore._models.Origin"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"create_connection of AsyncSOCKSProxy","ret_type":"httpcore._async.interfaces.AsyncConnectionInterface","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._async.socks_proxy.AsyncSOCKSProxy.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._async.socks_proxy.AsyncSOCKSProxy","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"AsyncSocks5Connection":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["httpcore._async.interfaces.AsyncConnectionInterface"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._async.socks_proxy.AsyncSocks5Connection","name":"AsyncSocks5Connection","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._async.socks_proxy.AsyncSocks5Connection","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._async.socks_proxy","mro":["httpcore._async.socks_proxy.AsyncSocks5Connection","httpcore._async.interfaces.AsyncConnectionInterface","httpcore._async.interfaces.AsyncRequestInterface","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1,1,1,1],"arg_names":["self","proxy_origin","remote_origin","proxy_auth","ssl_context","keepalive_expiry","http1","http2","network_backend"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.socks_proxy.AsyncSocks5Connection.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1,1,1],"arg_names":["self","proxy_origin","remote_origin","proxy_auth","ssl_context","keepalive_expiry","http1","http2","network_backend"],"arg_types":["httpcore._async.socks_proxy.AsyncSocks5Connection","httpcore._models.Origin","httpcore._models.Origin",{".class":"UnionType","items":[{".class":"TupleType","implicit":false,"items":["builtins.bytes","builtins.bytes"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool",{".class":"UnionType","items":["httpcore._backends.base.AsyncNetworkBackend",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of AsyncSocks5Connection","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.socks_proxy.AsyncSocks5Connection.__repr__","name":"__repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["httpcore._async.socks_proxy.AsyncSocks5Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr__ of AsyncSocks5Connection","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_connect_failed":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.socks_proxy.AsyncSocks5Connection._connect_failed","name":"_connect_failed","setter_type":null,"type":"builtins.bool"}},"_connect_lock":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.socks_proxy.AsyncSocks5Connection._connect_lock","name":"_connect_lock","setter_type":null,"type":"httpcore._synchronization.AsyncLock"}},"_connection":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._async.socks_proxy.AsyncSocks5Connection._connection","name":"_connection","setter_type":null,"type":{".class":"UnionType","items":["httpcore._async.interfaces.AsyncConnectionInterface",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_http1":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.socks_proxy.AsyncSocks5Connection._http1","name":"_http1","setter_type":null,"type":"builtins.bool"}},"_http2":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.socks_proxy.AsyncSocks5Connection._http2","name":"_http2","setter_type":null,"type":"builtins.bool"}},"_keepalive_expiry":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.socks_proxy.AsyncSocks5Connection._keepalive_expiry","name":"_keepalive_expiry","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_network_backend":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._async.socks_proxy.AsyncSocks5Connection._network_backend","name":"_network_backend","setter_type":null,"type":"httpcore._backends.base.AsyncNetworkBackend"}},"_proxy_auth":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.socks_proxy.AsyncSocks5Connection._proxy_auth","name":"_proxy_auth","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TupleType","implicit":false,"items":["builtins.bytes","builtins.bytes"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_proxy_origin":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.socks_proxy.AsyncSocks5Connection._proxy_origin","name":"_proxy_origin","setter_type":null,"type":"httpcore._models.Origin"}},"_remote_origin":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.socks_proxy.AsyncSocks5Connection._remote_origin","name":"_remote_origin","setter_type":null,"type":"httpcore._models.Origin"}},"_ssl_context":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._async.socks_proxy.AsyncSocks5Connection._ssl_context","name":"_ssl_context","setter_type":null,"type":{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"aclose":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.socks_proxy.AsyncSocks5Connection.aclose","name":"aclose","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.socks_proxy.AsyncSocks5Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"aclose of AsyncSocks5Connection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"can_handle_request":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","origin"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.socks_proxy.AsyncSocks5Connection.can_handle_request","name":"can_handle_request","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","origin"],"arg_types":["httpcore._async.socks_proxy.AsyncSocks5Connection","httpcore._models.Origin"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"can_handle_request of AsyncSocks5Connection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"handle_async_request":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._async.socks_proxy.AsyncSocks5Connection.handle_async_request","name":"handle_async_request","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["httpcore._async.socks_proxy.AsyncSocks5Connection","httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"handle_async_request of AsyncSocks5Connection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"httpcore._models.Response"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"has_expired":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.socks_proxy.AsyncSocks5Connection.has_expired","name":"has_expired","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.socks_proxy.AsyncSocks5Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"has_expired of AsyncSocks5Connection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"info":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.socks_proxy.AsyncSocks5Connection.info","name":"info","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.socks_proxy.AsyncSocks5Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"info of AsyncSocks5Connection","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_available":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.socks_proxy.AsyncSocks5Connection.is_available","name":"is_available","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.socks_proxy.AsyncSocks5Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_available of AsyncSocks5Connection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_closed":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.socks_proxy.AsyncSocks5Connection.is_closed","name":"is_closed","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.socks_proxy.AsyncSocks5Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_closed of AsyncSocks5Connection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_idle":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._async.socks_proxy.AsyncSocks5Connection.is_idle","name":"is_idle","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._async.socks_proxy.AsyncSocks5Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_idle of AsyncSocks5Connection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._async.socks_proxy.AsyncSocks5Connection.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._async.socks_proxy.AsyncSocks5Connection","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"AutoBackend":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.auto.AutoBackend","kind":"Gdef"},"ConnectionNotAvailable":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.ConnectionNotAvailable","kind":"Gdef"},"Origin":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Origin","kind":"Gdef"},"ProxyError":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.ProxyError","kind":"Gdef"},"REPLY_CODES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._async.socks_proxy.REPLY_CODES","name":"REPLY_CODES","setter_type":null,"type":{".class":"Instance","args":["builtins.bytes","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"Request":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Request","kind":"Gdef"},"Response":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Response","kind":"Gdef"},"Trace":{".class":"SymbolTableNode","cross_ref":"httpcore._trace.Trace","kind":"Gdef"},"URL":{".class":"SymbolTableNode","cross_ref":"httpcore._models.URL","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.socks_proxy.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.socks_proxy.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.socks_proxy.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.socks_proxy.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.socks_proxy.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._async.socks_proxy.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_init_socks5_connection":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,3,5],"arg_names":["stream","host","port","auth"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine"],"fullname":"httpcore._async.socks_proxy._init_socks5_connection","name":"_init_socks5_connection","original_first_arg":"stream","type":{".class":"CallableType","arg_kinds":[0,3,3,5],"arg_names":["stream","host","port","auth"],"arg_types":["httpcore._backends.base.AsyncNetworkStream","builtins.bytes","builtins.int",{".class":"UnionType","items":[{".class":"TupleType","implicit":false,"items":["builtins.bytes","builtins.bytes"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_init_socks5_connection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"default_ssl_context":{".class":"SymbolTableNode","cross_ref":"httpcore._ssl.default_ssl_context","kind":"Gdef"},"enforce_bytes":{".class":"SymbolTableNode","cross_ref":"httpcore._models.enforce_bytes","kind":"Gdef"},"enforce_url":{".class":"SymbolTableNode","cross_ref":"httpcore._models.enforce_url","kind":"Gdef"},"logger":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._async.socks_proxy.logger","name":"logger","setter_type":null,"type":"logging.Logger"}},"logging":{".class":"SymbolTableNode","cross_ref":"logging","kind":"Gdef"},"socksio":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"httpcore._async.socks_proxy.socksio","name":"socksio","setter_type":null,"type":{".class":"AnyType","missing_import_name":"httpcore._async.socks_proxy.socksio","source_any":null,"type_of_any":3}}},"ssl":{".class":"SymbolTableNode","cross_ref":"ssl","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_async/socks_proxy.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/socks_proxy.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/socks_proxy.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..ce295b0189c61a3c8c5acc64eebae1910fb92a26 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_async/socks_proxy.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[8,9,15,16,17,280,10,11,12,13,14,1,3,4,1,1,1,1,1,1,6],"dep_prios":[5,5,5,5,5,20,5,5,5,5,5,5,10,10,5,30,30,30,30,30,10],"dependencies":["httpcore._backends.auto","httpcore._backends.base","httpcore._async.connection_pool","httpcore._async.http11","httpcore._async.interfaces","httpcore._async.http2","httpcore._exceptions","httpcore._models","httpcore._ssl","httpcore._synchronization","httpcore._trace","__future__","logging","ssl","builtins","_frozen_importlib","_ssl","abc","httpcore._backends","typing"],"hash":"ac6eedea89b4b94ec20f824a184cfebc5347e4d4","id":"httpcore._async.socks_proxy","ignore_all":true,"interface_hash":"c5579e45e48574a0dff7a33736a915b8f293edc3","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_async/socks_proxy.py","plugin_data":null,"size":13841,"suppressed":["socksio"],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..37d25d0c965abf12ed00ffcd734fa3aa7d492c24 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"httpcore._backends","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_backends/__init__.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..62ada2535b5ab4cc77fb7a300ef8b533363e8b5b --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106713,"dep_lines":[1,1,1,1],"dep_prios":[5,30,30,30],"dependencies":["builtins","_frozen_importlib","abc","typing"],"hash":"da39a3ee5e6b4b0d3255bfef95601890afd80709","id":"httpcore._backends","ignore_all":true,"interface_hash":"79e1160a20bfaa4dec1e243cfe016dc610d3d5d9","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_backends/__init__.py","plugin_data":null,"size":0,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/anyio.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/anyio.data.json new file mode 100644 index 0000000000000000000000000000000000000000..b1c7296883ccefd1404889f3e6727c2c314c2281 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/anyio.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"httpcore._backends.anyio","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","AnyIOBackend":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["httpcore._backends.base.AsyncNetworkBackend"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._backends.anyio.AnyIOBackend","name":"AnyIOBackend","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._backends.anyio.AnyIOBackend","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._backends.anyio","mro":["httpcore._backends.anyio.AnyIOBackend","httpcore._backends.base.AsyncNetworkBackend","builtins.object"],"names":{".class":"SymbolTable","connect_tcp":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1],"arg_names":["self","host","port","timeout","local_address","socket_options"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._backends.anyio.AnyIOBackend.connect_tcp","name":"connect_tcp","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["self","host","port","timeout","local_address","socket_options"],"arg_types":["httpcore._backends.anyio.AnyIOBackend","builtins.str","builtins.int",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._backends.base.SOCKET_OPTION"}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"connect_tcp of AnyIOBackend","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"httpcore._backends.base.AsyncNetworkStream"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"connect_unix_socket":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","path","timeout","socket_options"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._backends.anyio.AnyIOBackend.connect_unix_socket","name":"connect_unix_socket","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","path","timeout","socket_options"],"arg_types":["httpcore._backends.anyio.AnyIOBackend","builtins.str",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._backends.base.SOCKET_OPTION"}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"connect_unix_socket of AnyIOBackend","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"httpcore._backends.base.AsyncNetworkStream"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"sleep":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","seconds"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._backends.anyio.AnyIOBackend.sleep","name":"sleep","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","seconds"],"arg_types":["httpcore._backends.anyio.AnyIOBackend","builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sleep of AnyIOBackend","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._backends.anyio.AnyIOBackend.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._backends.anyio.AnyIOBackend","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"AnyIOStream":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["httpcore._backends.base.AsyncNetworkStream"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._backends.anyio.AnyIOStream","name":"AnyIOStream","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._backends.anyio.AnyIOStream","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._backends.anyio","mro":["httpcore._backends.anyio.AnyIOStream","httpcore._backends.base.AsyncNetworkStream","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","stream"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.anyio.AnyIOStream.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","stream"],"arg_types":["httpcore._backends.anyio.AnyIOStream","anyio.abc._streams.ByteStream"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of AnyIOStream","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_stream":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._backends.anyio.AnyIOStream._stream","name":"_stream","setter_type":null,"type":"anyio.abc._streams.ByteStream"}},"aclose":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._backends.anyio.AnyIOStream.aclose","name":"aclose","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._backends.anyio.AnyIOStream"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"aclose of AnyIOStream","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_extra_info":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.anyio.AnyIOStream.get_extra_info","name":"get_extra_info","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","info"],"arg_types":["httpcore._backends.anyio.AnyIOStream","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_extra_info of AnyIOStream","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"read":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","max_bytes","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._backends.anyio.AnyIOStream.read","name":"read","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","max_bytes","timeout"],"arg_types":["httpcore._backends.anyio.AnyIOStream","builtins.int",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"read of AnyIOStream","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"start_tls":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","ssl_context","server_hostname","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._backends.anyio.AnyIOStream.start_tls","name":"start_tls","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","ssl_context","server_hostname","timeout"],"arg_types":["httpcore._backends.anyio.AnyIOStream","ssl.SSLContext",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"start_tls of AnyIOStream","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"httpcore._backends.base.AsyncNetworkStream"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"write":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","buffer","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._backends.anyio.AnyIOStream.write","name":"write","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","buffer","timeout"],"arg_types":["httpcore._backends.anyio.AnyIOStream","builtins.bytes",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"write of AnyIOStream","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._backends.anyio.AnyIOStream.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._backends.anyio.AnyIOStream","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"AsyncNetworkBackend":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.AsyncNetworkBackend","kind":"Gdef"},"AsyncNetworkStream":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.AsyncNetworkStream","kind":"Gdef"},"ConnectError":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.ConnectError","kind":"Gdef"},"ConnectTimeout":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.ConnectTimeout","kind":"Gdef"},"ReadError":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.ReadError","kind":"Gdef"},"ReadTimeout":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.ReadTimeout","kind":"Gdef"},"SOCKET_OPTION":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.SOCKET_OPTION","kind":"Gdef"},"WriteError":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.WriteError","kind":"Gdef"},"WriteTimeout":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.WriteTimeout","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.anyio.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.anyio.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.anyio.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.anyio.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.anyio.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.anyio.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"anyio":{".class":"SymbolTableNode","cross_ref":"anyio","kind":"Gdef"},"is_socket_readable":{".class":"SymbolTableNode","cross_ref":"httpcore._utils.is_socket_readable","kind":"Gdef"},"map_exceptions":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.map_exceptions","kind":"Gdef"},"ssl":{".class":"SymbolTableNode","cross_ref":"ssl","kind":"Gdef"},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_backends/anyio.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/anyio.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/anyio.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..e2760a08cbe122de927a5bf117d648c286516a01 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/anyio.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[18,8,17,1,3,4,6,1,1,1,1,1,1,1,1,1],"dep_prios":[5,5,5,5,10,10,10,5,30,30,30,30,30,30,30,30],"dependencies":["httpcore._backends.base","httpcore._exceptions","httpcore._utils","__future__","ssl","typing","anyio","builtins","_frozen_importlib","_ssl","abc","anyio._core","anyio._core._typedattr","anyio.abc","anyio.abc._resources","anyio.abc._streams"],"hash":"81cffa237a37043dee9f9747e1c54fbb8ad8f621","id":"httpcore._backends.anyio","ignore_all":true,"interface_hash":"afcc135380da1b23188255f53c119b646c382e1d","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_backends/anyio.py","plugin_data":null,"size":5252,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/auto.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/auto.data.json new file mode 100644 index 0000000000000000000000000000000000000000..fd4fb207a60addf2b9888c0c48fd027cb4578e06 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/auto.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"httpcore._backends.auto","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","AsyncNetworkBackend":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.AsyncNetworkBackend","kind":"Gdef"},"AsyncNetworkStream":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.AsyncNetworkStream","kind":"Gdef"},"AutoBackend":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["httpcore._backends.base.AsyncNetworkBackend"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._backends.auto.AutoBackend","name":"AutoBackend","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._backends.auto.AutoBackend","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._backends.auto","mro":["httpcore._backends.auto.AutoBackend","httpcore._backends.base.AsyncNetworkBackend","builtins.object"],"names":{".class":"SymbolTable","_backend":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._backends.auto.AutoBackend._backend","name":"_backend","setter_type":null,"type":"httpcore._backends.base.AsyncNetworkBackend"}},"_init_backend":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._backends.auto.AutoBackend._init_backend","name":"_init_backend","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._backends.auto.AutoBackend"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_init_backend of AutoBackend","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"connect_tcp":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1],"arg_names":["self","host","port","timeout","local_address","socket_options"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._backends.auto.AutoBackend.connect_tcp","name":"connect_tcp","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["self","host","port","timeout","local_address","socket_options"],"arg_types":["httpcore._backends.auto.AutoBackend","builtins.str","builtins.int",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._backends.base.SOCKET_OPTION"}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"connect_tcp of AutoBackend","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"httpcore._backends.base.AsyncNetworkStream"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"connect_unix_socket":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","path","timeout","socket_options"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._backends.auto.AutoBackend.connect_unix_socket","name":"connect_unix_socket","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","path","timeout","socket_options"],"arg_types":["httpcore._backends.auto.AutoBackend","builtins.str",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._backends.base.SOCKET_OPTION"}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"connect_unix_socket of AutoBackend","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"httpcore._backends.base.AsyncNetworkStream"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"sleep":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","seconds"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._backends.auto.AutoBackend.sleep","name":"sleep","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","seconds"],"arg_types":["httpcore._backends.auto.AutoBackend","builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sleep of AutoBackend","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._backends.auto.AutoBackend.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._backends.auto.AutoBackend","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"SOCKET_OPTION":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.SOCKET_OPTION","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.auto.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.auto.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.auto.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.auto.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.auto.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.auto.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"current_async_library":{".class":"SymbolTableNode","cross_ref":"httpcore._synchronization.current_async_library","kind":"Gdef"},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_backends/auto.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/auto.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/auto.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..0359c0f7fd530043047addb8ea301afd2426ab5d --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/auto.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[6,14,18,5,1,3,1,1,1],"dep_prios":[5,20,20,5,5,10,5,30,30],"dependencies":["httpcore._backends.base","httpcore._backends.trio","httpcore._backends.anyio","httpcore._synchronization","__future__","typing","builtins","_frozen_importlib","abc"],"hash":"df39f667c64290a3ba22519b2ee7f3151a1c54c2","id":"httpcore._backends.auto","ignore_all":true,"interface_hash":"8662ffec4b1122218e3aeca6c8ec3a1842e920c7","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_backends/auto.py","plugin_data":null,"size":1662,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/base.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/base.data.json new file mode 100644 index 0000000000000000000000000000000000000000..435cd2a3cc81409516d03b267094e3db64698efc --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/base.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"httpcore._backends.base","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","AsyncNetworkBackend":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._backends.base.AsyncNetworkBackend","name":"AsyncNetworkBackend","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._backends.base.AsyncNetworkBackend","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._backends.base","mro":["httpcore._backends.base.AsyncNetworkBackend","builtins.object"],"names":{".class":"SymbolTable","connect_tcp":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1],"arg_names":["self","host","port","timeout","local_address","socket_options"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._backends.base.AsyncNetworkBackend.connect_tcp","name":"connect_tcp","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["self","host","port","timeout","local_address","socket_options"],"arg_types":["httpcore._backends.base.AsyncNetworkBackend","builtins.str","builtins.int",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._backends.base.SOCKET_OPTION"}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"connect_tcp of AsyncNetworkBackend","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"httpcore._backends.base.AsyncNetworkStream"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"connect_unix_socket":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","path","timeout","socket_options"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._backends.base.AsyncNetworkBackend.connect_unix_socket","name":"connect_unix_socket","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","path","timeout","socket_options"],"arg_types":["httpcore._backends.base.AsyncNetworkBackend","builtins.str",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._backends.base.SOCKET_OPTION"}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"connect_unix_socket of AsyncNetworkBackend","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"httpcore._backends.base.AsyncNetworkStream"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"sleep":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","seconds"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._backends.base.AsyncNetworkBackend.sleep","name":"sleep","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","seconds"],"arg_types":["httpcore._backends.base.AsyncNetworkBackend","builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sleep of AsyncNetworkBackend","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._backends.base.AsyncNetworkBackend.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._backends.base.AsyncNetworkBackend","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"AsyncNetworkStream":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._backends.base.AsyncNetworkStream","name":"AsyncNetworkStream","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._backends.base.AsyncNetworkStream","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._backends.base","mro":["httpcore._backends.base.AsyncNetworkStream","builtins.object"],"names":{".class":"SymbolTable","aclose":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._backends.base.AsyncNetworkStream.aclose","name":"aclose","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._backends.base.AsyncNetworkStream"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"aclose of AsyncNetworkStream","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_extra_info":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.base.AsyncNetworkStream.get_extra_info","name":"get_extra_info","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","info"],"arg_types":["httpcore._backends.base.AsyncNetworkStream","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_extra_info of AsyncNetworkStream","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"read":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","max_bytes","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._backends.base.AsyncNetworkStream.read","name":"read","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","max_bytes","timeout"],"arg_types":["httpcore._backends.base.AsyncNetworkStream","builtins.int",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"read of AsyncNetworkStream","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"start_tls":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","ssl_context","server_hostname","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._backends.base.AsyncNetworkStream.start_tls","name":"start_tls","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","ssl_context","server_hostname","timeout"],"arg_types":["httpcore._backends.base.AsyncNetworkStream","ssl.SSLContext",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"start_tls of AsyncNetworkStream","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"httpcore._backends.base.AsyncNetworkStream"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"write":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","buffer","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._backends.base.AsyncNetworkStream.write","name":"write","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","buffer","timeout"],"arg_types":["httpcore._backends.base.AsyncNetworkStream","builtins.bytes",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"write of AsyncNetworkStream","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._backends.base.AsyncNetworkStream.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._backends.base.AsyncNetworkStream","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"NetworkBackend":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._backends.base.NetworkBackend","name":"NetworkBackend","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._backends.base.NetworkBackend","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._backends.base","mro":["httpcore._backends.base.NetworkBackend","builtins.object"],"names":{".class":"SymbolTable","connect_tcp":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1],"arg_names":["self","host","port","timeout","local_address","socket_options"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.base.NetworkBackend.connect_tcp","name":"connect_tcp","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["self","host","port","timeout","local_address","socket_options"],"arg_types":["httpcore._backends.base.NetworkBackend","builtins.str","builtins.int",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._backends.base.SOCKET_OPTION"}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"connect_tcp of NetworkBackend","ret_type":"httpcore._backends.base.NetworkStream","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"connect_unix_socket":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","path","timeout","socket_options"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.base.NetworkBackend.connect_unix_socket","name":"connect_unix_socket","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","path","timeout","socket_options"],"arg_types":["httpcore._backends.base.NetworkBackend","builtins.str",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._backends.base.SOCKET_OPTION"}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"connect_unix_socket of NetworkBackend","ret_type":"httpcore._backends.base.NetworkStream","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"sleep":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","seconds"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.base.NetworkBackend.sleep","name":"sleep","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","seconds"],"arg_types":["httpcore._backends.base.NetworkBackend","builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sleep of NetworkBackend","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._backends.base.NetworkBackend.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._backends.base.NetworkBackend","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"NetworkStream":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._backends.base.NetworkStream","name":"NetworkStream","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._backends.base.NetworkStream","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._backends.base","mro":["httpcore._backends.base.NetworkStream","builtins.object"],"names":{".class":"SymbolTable","close":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.base.NetworkStream.close","name":"close","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._backends.base.NetworkStream"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"close of NetworkStream","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_extra_info":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.base.NetworkStream.get_extra_info","name":"get_extra_info","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","info"],"arg_types":["httpcore._backends.base.NetworkStream","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_extra_info of NetworkStream","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"read":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","max_bytes","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.base.NetworkStream.read","name":"read","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","max_bytes","timeout"],"arg_types":["httpcore._backends.base.NetworkStream","builtins.int",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"read of NetworkStream","ret_type":"builtins.bytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"start_tls":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","ssl_context","server_hostname","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.base.NetworkStream.start_tls","name":"start_tls","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","ssl_context","server_hostname","timeout"],"arg_types":["httpcore._backends.base.NetworkStream","ssl.SSLContext",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"start_tls of NetworkStream","ret_type":"httpcore._backends.base.NetworkStream","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"write":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","buffer","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.base.NetworkStream.write","name":"write","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","buffer","timeout"],"arg_types":["httpcore._backends.base.NetworkStream","builtins.bytes",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"write of NetworkStream","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._backends.base.NetworkStream.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._backends.base.NetworkStream","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"SOCKET_OPTION":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"httpcore._backends.base.SOCKET_OPTION","line":7,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int",{".class":"UnionType","items":["builtins.bytes","builtins.bytearray"],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int",{".class":"NoneType"},"builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":false}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.base.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.base.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.base.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.base.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.base.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.base.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"ssl":{".class":"SymbolTableNode","cross_ref":"ssl","kind":"Gdef"},"time":{".class":"SymbolTableNode","cross_ref":"time","kind":"Gdef"},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_backends/base.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/base.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/base.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..ba2bacc8f6bea1e19a554ac707fe9d767c37bd65 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/base.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106714,"dep_lines":[1,3,4,5,1,1,1,1],"dep_prios":[5,10,10,10,5,30,30,30],"dependencies":["__future__","ssl","time","typing","builtins","_frozen_importlib","_ssl","abc"],"hash":"3faa652cb4036112775ff070c89b0539fbd25972","id":"httpcore._backends.base","ignore_all":true,"interface_hash":"071560ef3cf7b062617a56ea60f9dc2696c92e5f","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_backends/base.py","plugin_data":null,"size":3042,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/mock.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/mock.data.json new file mode 100644 index 0000000000000000000000000000000000000000..8990415faab619834b90896d785cc9a5118169fb --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/mock.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"httpcore._backends.mock","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","AsyncMockBackend":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["httpcore._backends.base.AsyncNetworkBackend"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._backends.mock.AsyncMockBackend","name":"AsyncMockBackend","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._backends.mock.AsyncMockBackend","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._backends.mock","mro":["httpcore._backends.mock.AsyncMockBackend","httpcore._backends.base.AsyncNetworkBackend","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","buffer","http2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.mock.AsyncMockBackend.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","buffer","http2"],"arg_types":["httpcore._backends.mock.AsyncMockBackend",{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"builtins.list"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of AsyncMockBackend","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_buffer":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._backends.mock.AsyncMockBackend._buffer","name":"_buffer","setter_type":null,"type":{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"builtins.list"}}},"_http2":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._backends.mock.AsyncMockBackend._http2","name":"_http2","setter_type":null,"type":"builtins.bool"}},"connect_tcp":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1],"arg_names":["self","host","port","timeout","local_address","socket_options"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._backends.mock.AsyncMockBackend.connect_tcp","name":"connect_tcp","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["self","host","port","timeout","local_address","socket_options"],"arg_types":["httpcore._backends.mock.AsyncMockBackend","builtins.str","builtins.int",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._backends.base.SOCKET_OPTION"}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"connect_tcp of AsyncMockBackend","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"httpcore._backends.base.AsyncNetworkStream"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"connect_unix_socket":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","path","timeout","socket_options"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._backends.mock.AsyncMockBackend.connect_unix_socket","name":"connect_unix_socket","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","path","timeout","socket_options"],"arg_types":["httpcore._backends.mock.AsyncMockBackend","builtins.str",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._backends.base.SOCKET_OPTION"}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"connect_unix_socket of AsyncMockBackend","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"httpcore._backends.base.AsyncNetworkStream"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"sleep":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","seconds"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._backends.mock.AsyncMockBackend.sleep","name":"sleep","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","seconds"],"arg_types":["httpcore._backends.mock.AsyncMockBackend","builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sleep of AsyncMockBackend","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._backends.mock.AsyncMockBackend.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._backends.mock.AsyncMockBackend","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"AsyncMockStream":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["httpcore._backends.base.AsyncNetworkStream"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._backends.mock.AsyncMockStream","name":"AsyncMockStream","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._backends.mock.AsyncMockStream","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._backends.mock","mro":["httpcore._backends.mock.AsyncMockStream","httpcore._backends.base.AsyncNetworkStream","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","buffer","http2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.mock.AsyncMockStream.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","buffer","http2"],"arg_types":["httpcore._backends.mock.AsyncMockStream",{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"builtins.list"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of AsyncMockStream","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.mock.AsyncMockStream.__repr__","name":"__repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["httpcore._backends.mock.AsyncMockStream"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr__ of AsyncMockStream","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_buffer":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._backends.mock.AsyncMockStream._buffer","name":"_buffer","setter_type":null,"type":{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"builtins.list"}}},"_closed":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._backends.mock.AsyncMockStream._closed","name":"_closed","setter_type":null,"type":"builtins.bool"}},"_http2":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._backends.mock.AsyncMockStream._http2","name":"_http2","setter_type":null,"type":"builtins.bool"}},"aclose":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._backends.mock.AsyncMockStream.aclose","name":"aclose","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._backends.mock.AsyncMockStream"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"aclose of AsyncMockStream","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_extra_info":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.mock.AsyncMockStream.get_extra_info","name":"get_extra_info","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","info"],"arg_types":["httpcore._backends.mock.AsyncMockStream","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_extra_info of AsyncMockStream","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"read":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","max_bytes","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._backends.mock.AsyncMockStream.read","name":"read","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","max_bytes","timeout"],"arg_types":["httpcore._backends.mock.AsyncMockStream","builtins.int",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"read of AsyncMockStream","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"start_tls":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","ssl_context","server_hostname","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._backends.mock.AsyncMockStream.start_tls","name":"start_tls","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","ssl_context","server_hostname","timeout"],"arg_types":["httpcore._backends.mock.AsyncMockStream","ssl.SSLContext",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"start_tls of AsyncMockStream","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"httpcore._backends.base.AsyncNetworkStream"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"write":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","buffer","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._backends.mock.AsyncMockStream.write","name":"write","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","buffer","timeout"],"arg_types":["httpcore._backends.mock.AsyncMockStream","builtins.bytes",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"write of AsyncMockStream","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._backends.mock.AsyncMockStream.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._backends.mock.AsyncMockStream","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"AsyncNetworkBackend":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.AsyncNetworkBackend","kind":"Gdef"},"AsyncNetworkStream":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.AsyncNetworkStream","kind":"Gdef"},"MockBackend":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["httpcore._backends.base.NetworkBackend"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._backends.mock.MockBackend","name":"MockBackend","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._backends.mock.MockBackend","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._backends.mock","mro":["httpcore._backends.mock.MockBackend","httpcore._backends.base.NetworkBackend","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","buffer","http2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.mock.MockBackend.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","buffer","http2"],"arg_types":["httpcore._backends.mock.MockBackend",{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"builtins.list"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of MockBackend","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_buffer":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._backends.mock.MockBackend._buffer","name":"_buffer","setter_type":null,"type":{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"builtins.list"}}},"_http2":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._backends.mock.MockBackend._http2","name":"_http2","setter_type":null,"type":"builtins.bool"}},"connect_tcp":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1],"arg_names":["self","host","port","timeout","local_address","socket_options"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.mock.MockBackend.connect_tcp","name":"connect_tcp","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["self","host","port","timeout","local_address","socket_options"],"arg_types":["httpcore._backends.mock.MockBackend","builtins.str","builtins.int",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._backends.base.SOCKET_OPTION"}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"connect_tcp of MockBackend","ret_type":"httpcore._backends.base.NetworkStream","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"connect_unix_socket":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","path","timeout","socket_options"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.mock.MockBackend.connect_unix_socket","name":"connect_unix_socket","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","path","timeout","socket_options"],"arg_types":["httpcore._backends.mock.MockBackend","builtins.str",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._backends.base.SOCKET_OPTION"}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"connect_unix_socket of MockBackend","ret_type":"httpcore._backends.base.NetworkStream","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"sleep":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","seconds"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.mock.MockBackend.sleep","name":"sleep","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","seconds"],"arg_types":["httpcore._backends.mock.MockBackend","builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sleep of MockBackend","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._backends.mock.MockBackend.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._backends.mock.MockBackend","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"MockSSLObject":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._backends.mock.MockSSLObject","name":"MockSSLObject","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._backends.mock.MockSSLObject","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._backends.mock","mro":["httpcore._backends.mock.MockSSLObject","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","http2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.mock.MockSSLObject.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","http2"],"arg_types":["httpcore._backends.mock.MockSSLObject","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of MockSSLObject","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_http2":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._backends.mock.MockSSLObject._http2","name":"_http2","setter_type":null,"type":"builtins.bool"}},"selected_alpn_protocol":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.mock.MockSSLObject.selected_alpn_protocol","name":"selected_alpn_protocol","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._backends.mock.MockSSLObject"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"selected_alpn_protocol of MockSSLObject","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._backends.mock.MockSSLObject.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._backends.mock.MockSSLObject","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"MockStream":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["httpcore._backends.base.NetworkStream"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._backends.mock.MockStream","name":"MockStream","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._backends.mock.MockStream","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._backends.mock","mro":["httpcore._backends.mock.MockStream","httpcore._backends.base.NetworkStream","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","buffer","http2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.mock.MockStream.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","buffer","http2"],"arg_types":["httpcore._backends.mock.MockStream",{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"builtins.list"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of MockStream","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.mock.MockStream.__repr__","name":"__repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["httpcore._backends.mock.MockStream"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr__ of MockStream","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_buffer":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._backends.mock.MockStream._buffer","name":"_buffer","setter_type":null,"type":{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"builtins.list"}}},"_closed":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._backends.mock.MockStream._closed","name":"_closed","setter_type":null,"type":"builtins.bool"}},"_http2":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._backends.mock.MockStream._http2","name":"_http2","setter_type":null,"type":"builtins.bool"}},"close":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.mock.MockStream.close","name":"close","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._backends.mock.MockStream"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"close of MockStream","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_extra_info":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.mock.MockStream.get_extra_info","name":"get_extra_info","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","info"],"arg_types":["httpcore._backends.mock.MockStream","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_extra_info of MockStream","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"read":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","max_bytes","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.mock.MockStream.read","name":"read","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","max_bytes","timeout"],"arg_types":["httpcore._backends.mock.MockStream","builtins.int",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"read of MockStream","ret_type":"builtins.bytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"start_tls":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","ssl_context","server_hostname","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.mock.MockStream.start_tls","name":"start_tls","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","ssl_context","server_hostname","timeout"],"arg_types":["httpcore._backends.mock.MockStream","ssl.SSLContext",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"start_tls of MockStream","ret_type":"httpcore._backends.base.NetworkStream","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"write":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","buffer","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.mock.MockStream.write","name":"write","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","buffer","timeout"],"arg_types":["httpcore._backends.mock.MockStream","builtins.bytes",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"write of MockStream","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._backends.mock.MockStream.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._backends.mock.MockStream","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"NetworkBackend":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.NetworkBackend","kind":"Gdef"},"NetworkStream":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.NetworkStream","kind":"Gdef"},"ReadError":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.ReadError","kind":"Gdef"},"SOCKET_OPTION":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.SOCKET_OPTION","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.mock.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.mock.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.mock.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.mock.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.mock.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.mock.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"ssl":{".class":"SymbolTableNode","cross_ref":"ssl","kind":"Gdef"},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_backends/mock.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/mock.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/mock.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..648945fa7e34ba0447e38bde6f041d2d2403d10c --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/mock.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[7,6,1,3,4,1,1,1,1],"dep_prios":[5,5,5,10,10,5,30,30,30],"dependencies":["httpcore._backends.base","httpcore._exceptions","__future__","ssl","typing","builtins","_frozen_importlib","_ssl","abc"],"hash":"fee59bcf40d6bc51917172474a5a5c49d1b24d27","id":"httpcore._backends.mock","ignore_all":true,"interface_hash":"077b4a2b5f8642ca32f61af91ae29d24e7fbae55","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_backends/mock.py","plugin_data":null,"size":4077,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/sync.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/sync.data.json new file mode 100644 index 0000000000000000000000000000000000000000..64929f90e1dc5b6807eaf32c2d2fa20ca856a809 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/sync.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"httpcore._backends.sync","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","ConnectError":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.ConnectError","kind":"Gdef"},"ConnectTimeout":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.ConnectTimeout","kind":"Gdef"},"ExceptionMapping":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.ExceptionMapping","kind":"Gdef"},"NetworkBackend":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.NetworkBackend","kind":"Gdef"},"NetworkStream":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.NetworkStream","kind":"Gdef"},"ReadError":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.ReadError","kind":"Gdef"},"ReadTimeout":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.ReadTimeout","kind":"Gdef"},"SOCKET_OPTION":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.SOCKET_OPTION","kind":"Gdef"},"SyncBackend":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["httpcore._backends.base.NetworkBackend"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._backends.sync.SyncBackend","name":"SyncBackend","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._backends.sync.SyncBackend","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._backends.sync","mro":["httpcore._backends.sync.SyncBackend","httpcore._backends.base.NetworkBackend","builtins.object"],"names":{".class":"SymbolTable","connect_tcp":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1],"arg_names":["self","host","port","timeout","local_address","socket_options"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.sync.SyncBackend.connect_tcp","name":"connect_tcp","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["self","host","port","timeout","local_address","socket_options"],"arg_types":["httpcore._backends.sync.SyncBackend","builtins.str","builtins.int",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._backends.base.SOCKET_OPTION"}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"connect_tcp of SyncBackend","ret_type":"httpcore._backends.base.NetworkStream","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"connect_unix_socket":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","path","timeout","socket_options"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.sync.SyncBackend.connect_unix_socket","name":"connect_unix_socket","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","path","timeout","socket_options"],"arg_types":["httpcore._backends.sync.SyncBackend","builtins.str",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._backends.base.SOCKET_OPTION"}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"connect_unix_socket of SyncBackend","ret_type":"httpcore._backends.base.NetworkStream","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._backends.sync.SyncBackend.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._backends.sync.SyncBackend","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"SyncStream":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["httpcore._backends.base.NetworkStream"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._backends.sync.SyncStream","name":"SyncStream","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._backends.sync.SyncStream","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._backends.sync","mro":["httpcore._backends.sync.SyncStream","httpcore._backends.base.NetworkStream","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","sock"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.sync.SyncStream.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","sock"],"arg_types":["httpcore._backends.sync.SyncStream","socket.socket"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of SyncStream","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_sock":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._backends.sync.SyncStream._sock","name":"_sock","setter_type":null,"type":"socket.socket"}},"close":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.sync.SyncStream.close","name":"close","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._backends.sync.SyncStream"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"close of SyncStream","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_extra_info":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.sync.SyncStream.get_extra_info","name":"get_extra_info","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","info"],"arg_types":["httpcore._backends.sync.SyncStream","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_extra_info of SyncStream","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"read":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","max_bytes","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.sync.SyncStream.read","name":"read","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","max_bytes","timeout"],"arg_types":["httpcore._backends.sync.SyncStream","builtins.int",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"read of SyncStream","ret_type":"builtins.bytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"start_tls":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","ssl_context","server_hostname","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.sync.SyncStream.start_tls","name":"start_tls","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","ssl_context","server_hostname","timeout"],"arg_types":["httpcore._backends.sync.SyncStream","ssl.SSLContext",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"start_tls of SyncStream","ret_type":"httpcore._backends.base.NetworkStream","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"write":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","buffer","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.sync.SyncStream.write","name":"write","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","buffer","timeout"],"arg_types":["httpcore._backends.sync.SyncStream","builtins.bytes",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"write of SyncStream","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._backends.sync.SyncStream.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._backends.sync.SyncStream","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TLSinTLSStream":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["httpcore._backends.base.NetworkStream"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._backends.sync.TLSinTLSStream","name":"TLSinTLSStream","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._backends.sync.TLSinTLSStream","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._backends.sync","mro":["httpcore._backends.sync.TLSinTLSStream","httpcore._backends.base.NetworkStream","builtins.object"],"names":{".class":"SymbolTable","TLS_RECORD_SIZE":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._backends.sync.TLSinTLSStream.TLS_RECORD_SIZE","name":"TLS_RECORD_SIZE","setter_type":null,"type":"builtins.int"}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1],"arg_names":["self","sock","ssl_context","server_hostname","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.sync.TLSinTLSStream.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1],"arg_names":["self","sock","ssl_context","server_hostname","timeout"],"arg_types":["httpcore._backends.sync.TLSinTLSStream","socket.socket","ssl.SSLContext",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of TLSinTLSStream","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_incoming":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._backends.sync.TLSinTLSStream._incoming","name":"_incoming","setter_type":null,"type":"_ssl.MemoryBIO"}},"_outgoing":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._backends.sync.TLSinTLSStream._outgoing","name":"_outgoing","setter_type":null,"type":"_ssl.MemoryBIO"}},"_perform_io":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","func"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.sync.TLSinTLSStream._perform_io","name":"_perform_io","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","func"],"arg_types":["httpcore._backends.sync.TLSinTLSStream",{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_perform_io of TLSinTLSStream","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_sock":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._backends.sync.TLSinTLSStream._sock","name":"_sock","setter_type":null,"type":"socket.socket"}},"close":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.sync.TLSinTLSStream.close","name":"close","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._backends.sync.TLSinTLSStream"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"close of TLSinTLSStream","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_extra_info":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.sync.TLSinTLSStream.get_extra_info","name":"get_extra_info","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","info"],"arg_types":["httpcore._backends.sync.TLSinTLSStream","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_extra_info of TLSinTLSStream","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"read":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","max_bytes","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.sync.TLSinTLSStream.read","name":"read","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","max_bytes","timeout"],"arg_types":["httpcore._backends.sync.TLSinTLSStream","builtins.int",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"read of TLSinTLSStream","ret_type":"builtins.bytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"ssl_obj":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._backends.sync.TLSinTLSStream.ssl_obj","name":"ssl_obj","setter_type":null,"type":"ssl.SSLObject"}},"start_tls":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","ssl_context","server_hostname","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.sync.TLSinTLSStream.start_tls","name":"start_tls","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","ssl_context","server_hostname","timeout"],"arg_types":["httpcore._backends.sync.TLSinTLSStream","ssl.SSLContext",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"start_tls of TLSinTLSStream","ret_type":"httpcore._backends.base.NetworkStream","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"write":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","buffer","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.sync.TLSinTLSStream.write","name":"write","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","buffer","timeout"],"arg_types":["httpcore._backends.sync.TLSinTLSStream","builtins.bytes",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"write of TLSinTLSStream","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._backends.sync.TLSinTLSStream.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._backends.sync.TLSinTLSStream","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"WriteError":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.WriteError","kind":"Gdef"},"WriteTimeout":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.WriteTimeout","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.sync.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.sync.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.sync.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.sync.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.sync.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.sync.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"functools":{".class":"SymbolTableNode","cross_ref":"functools","kind":"Gdef"},"is_socket_readable":{".class":"SymbolTableNode","cross_ref":"httpcore._utils.is_socket_readable","kind":"Gdef"},"map_exceptions":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.map_exceptions","kind":"Gdef"},"socket":{".class":"SymbolTableNode","cross_ref":"socket","kind":"Gdef"},"ssl":{".class":"SymbolTableNode","cross_ref":"ssl","kind":"Gdef"},"sys":{".class":"SymbolTableNode","cross_ref":"sys","kind":"Gdef"},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_backends/sync.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/sync.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/sync.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..c310b99f60b85960d8f298d320ab970d3f3cb446 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/sync.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[20,9,19,1,3,4,5,6,7,1,1,1,1,1],"dep_prios":[5,5,5,5,10,10,10,10,10,5,30,30,30,30],"dependencies":["httpcore._backends.base","httpcore._exceptions","httpcore._utils","__future__","functools","socket","ssl","sys","typing","builtins","_frozen_importlib","_socket","_ssl","abc"],"hash":"63837d17d3e6c826846ef4caaf82b62d116574cf","id":"httpcore._backends.sync","ignore_all":true,"interface_hash":"57b90e835d29e4f583ab30d2fbfc17b4c3e2f5a2","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_backends/sync.py","plugin_data":null,"size":7977,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/trio.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/trio.data.json new file mode 100644 index 0000000000000000000000000000000000000000..6a3d125d1c0515a326f552357139a9f93b1f60ea --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/trio.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"httpcore._backends.trio","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","AsyncNetworkBackend":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.AsyncNetworkBackend","kind":"Gdef"},"AsyncNetworkStream":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.AsyncNetworkStream","kind":"Gdef"},"ConnectError":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.ConnectError","kind":"Gdef"},"ConnectTimeout":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.ConnectTimeout","kind":"Gdef"},"ExceptionMapping":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.ExceptionMapping","kind":"Gdef"},"ReadError":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.ReadError","kind":"Gdef"},"ReadTimeout":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.ReadTimeout","kind":"Gdef"},"SOCKET_OPTION":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.SOCKET_OPTION","kind":"Gdef"},"TrioBackend":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["httpcore._backends.base.AsyncNetworkBackend"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._backends.trio.TrioBackend","name":"TrioBackend","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._backends.trio.TrioBackend","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._backends.trio","mro":["httpcore._backends.trio.TrioBackend","httpcore._backends.base.AsyncNetworkBackend","builtins.object"],"names":{".class":"SymbolTable","connect_tcp":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1],"arg_names":["self","host","port","timeout","local_address","socket_options"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._backends.trio.TrioBackend.connect_tcp","name":"connect_tcp","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["self","host","port","timeout","local_address","socket_options"],"arg_types":["httpcore._backends.trio.TrioBackend","builtins.str","builtins.int",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._backends.base.SOCKET_OPTION"}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"connect_tcp of TrioBackend","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"httpcore._backends.base.AsyncNetworkStream"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"connect_unix_socket":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","path","timeout","socket_options"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._backends.trio.TrioBackend.connect_unix_socket","name":"connect_unix_socket","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","path","timeout","socket_options"],"arg_types":["httpcore._backends.trio.TrioBackend","builtins.str",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._backends.base.SOCKET_OPTION"}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"connect_unix_socket of TrioBackend","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"httpcore._backends.base.AsyncNetworkStream"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"sleep":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","seconds"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._backends.trio.TrioBackend.sleep","name":"sleep","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","seconds"],"arg_types":["httpcore._backends.trio.TrioBackend","builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sleep of TrioBackend","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._backends.trio.TrioBackend.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._backends.trio.TrioBackend","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TrioStream":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["httpcore._backends.base.AsyncNetworkStream"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._backends.trio.TrioStream","name":"TrioStream","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._backends.trio.TrioStream","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._backends.trio","mro":["httpcore._backends.trio.TrioStream","httpcore._backends.base.AsyncNetworkStream","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","stream"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.trio.TrioStream.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","stream"],"arg_types":["httpcore._backends.trio.TrioStream",{".class":"AnyType","missing_import_name":"httpcore._backends.trio.trio","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of TrioStream","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_get_socket_stream":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.trio.TrioStream._get_socket_stream","name":"_get_socket_stream","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._backends.trio.TrioStream"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_socket_stream of TrioStream","ret_type":{".class":"AnyType","missing_import_name":"httpcore._backends.trio.trio","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_stream":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._backends.trio.TrioStream._stream","name":"_stream","setter_type":null,"type":{".class":"AnyType","missing_import_name":"httpcore._backends.trio.trio","source_any":null,"type_of_any":3}}},"aclose":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._backends.trio.TrioStream.aclose","name":"aclose","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._backends.trio.TrioStream"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"aclose of TrioStream","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_extra_info":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._backends.trio.TrioStream.get_extra_info","name":"get_extra_info","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","info"],"arg_types":["httpcore._backends.trio.TrioStream","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_extra_info of TrioStream","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"read":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","max_bytes","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._backends.trio.TrioStream.read","name":"read","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","max_bytes","timeout"],"arg_types":["httpcore._backends.trio.TrioStream","builtins.int",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"read of TrioStream","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"start_tls":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","ssl_context","server_hostname","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._backends.trio.TrioStream.start_tls","name":"start_tls","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","ssl_context","server_hostname","timeout"],"arg_types":["httpcore._backends.trio.TrioStream","ssl.SSLContext",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"start_tls of TrioStream","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"httpcore._backends.base.AsyncNetworkStream"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"write":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","buffer","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"httpcore._backends.trio.TrioStream.write","name":"write","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","buffer","timeout"],"arg_types":["httpcore._backends.trio.TrioStream","builtins.bytes",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"write of TrioStream","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._backends.trio.TrioStream.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._backends.trio.TrioStream","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"WriteError":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.WriteError","kind":"Gdef"},"WriteTimeout":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.WriteTimeout","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.trio.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.trio.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.trio.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.trio.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.trio.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._backends.trio.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"map_exceptions":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.map_exceptions","kind":"Gdef"},"ssl":{".class":"SymbolTableNode","cross_ref":"ssl","kind":"Gdef"},"trio":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"httpcore._backends.trio.trio","name":"trio","setter_type":null,"type":{".class":"AnyType","missing_import_name":"httpcore._backends.trio.trio","source_any":null,"type_of_any":3}}},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_backends/trio.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/trio.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/trio.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..33109022aa740ea0a90738ef39ce458f0caaf580 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_backends/trio.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[18,8,1,3,4,1,1,1,1,6],"dep_prios":[5,5,5,10,10,5,30,30,30,10],"dependencies":["httpcore._backends.base","httpcore._exceptions","__future__","ssl","typing","builtins","_frozen_importlib","_ssl","abc"],"hash":"64b850cda4b89ae9e6401d4fd40a55dab2d384d2","id":"httpcore._backends.trio","ignore_all":true,"interface_hash":"7dc1c7655db88bc8bb511d8446ba7482a87133e7","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_backends/trio.py","plugin_data":null,"size":5996,"suppressed":["trio"],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..e19e12ac587d8d569a31f462839ceb9278cb6837 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"httpcore._sync","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","ConnectionInterface":{".class":"SymbolTableNode","cross_ref":"httpcore._sync.interfaces.ConnectionInterface","kind":"Gdef"},"ConnectionPool":{".class":"SymbolTableNode","cross_ref":"httpcore._sync.connection_pool.ConnectionPool","kind":"Gdef"},"HTTP11Connection":{".class":"SymbolTableNode","cross_ref":"httpcore._sync.http11.HTTP11Connection","kind":"Gdef"},"HTTP2Connection":{".class":"SymbolTableNode","cross_ref":"httpcore._sync.http2.HTTP2Connection","kind":"Gdef"},"HTTPConnection":{".class":"SymbolTableNode","cross_ref":"httpcore._sync.connection.HTTPConnection","kind":"Gdef"},"HTTPProxy":{".class":"SymbolTableNode","cross_ref":"httpcore._sync.http_proxy.HTTPProxy","kind":"Gdef"},"SOCKSProxy":{".class":"SymbolTableNode","cross_ref":"httpcore._sync.socks_proxy.SOCKSProxy","kind":"Gdef"},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._sync.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_sync/__init__.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..7fd4dc9a4965959f4cb19398815f620651328ec3 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,2,3,4,5,8,20,1,1,1,1],"dep_prios":[5,5,5,5,5,5,5,5,30,30,30],"dependencies":["httpcore._sync.connection","httpcore._sync.connection_pool","httpcore._sync.http11","httpcore._sync.http_proxy","httpcore._sync.interfaces","httpcore._sync.http2","httpcore._sync.socks_proxy","builtins","_frozen_importlib","abc","typing"],"hash":"c43e980b1d24e1b2425e8426aea879942b8e43c5","id":"httpcore._sync","ignore_all":true,"interface_hash":"db095f3e5e48bd1134a84933ce8abb70a52aa49a","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_sync/__init__.py","plugin_data":null,"size":1141,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/connection.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/connection.data.json new file mode 100644 index 0000000000000000000000000000000000000000..481acc009066772060c093cee11ad70d51f18031 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/connection.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"httpcore._sync.connection","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","ConnectError":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.ConnectError","kind":"Gdef"},"ConnectTimeout":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.ConnectTimeout","kind":"Gdef"},"ConnectionInterface":{".class":"SymbolTableNode","cross_ref":"httpcore._sync.interfaces.ConnectionInterface","kind":"Gdef"},"HTTP11Connection":{".class":"SymbolTableNode","cross_ref":"httpcore._sync.http11.HTTP11Connection","kind":"Gdef"},"HTTPConnection":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["httpcore._sync.interfaces.ConnectionInterface"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._sync.connection.HTTPConnection","name":"HTTPConnection","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._sync.connection.HTTPConnection","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._sync.connection","mro":["httpcore._sync.connection.HTTPConnection","httpcore._sync.interfaces.ConnectionInterface","httpcore._sync.interfaces.RequestInterface","builtins.object"],"names":{".class":"SymbolTable","__enter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.connection.HTTPConnection.__enter__","name":"__enter__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["httpcore._sync.connection.HTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__enter__ of HTTPConnection","ret_type":"httpcore._sync.connection.HTTPConnection","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__exit__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":[null,null,null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.connection.HTTPConnection.__exit__","name":"__exit__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":[null,null,null,null],"arg_types":["httpcore._sync.connection.HTTPConnection",{".class":"UnionType","items":[{".class":"TypeType","item":"builtins.BaseException"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.BaseException",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["types.TracebackType",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__exit__ of HTTPConnection","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,1,1,1,1],"arg_names":["self","origin","ssl_context","keepalive_expiry","http1","http2","retries","local_address","uds","network_backend","socket_options"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.connection.HTTPConnection.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1,1,1,1],"arg_names":["self","origin","ssl_context","keepalive_expiry","http1","http2","retries","local_address","uds","network_backend","socket_options"],"arg_types":["httpcore._sync.connection.HTTPConnection","httpcore._models.Origin",{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool","builtins.int",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["httpcore._backends.base.NetworkBackend",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._backends.base.SOCKET_OPTION"}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of HTTPConnection","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.connection.HTTPConnection.__repr__","name":"__repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["httpcore._sync.connection.HTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr__ of HTTPConnection","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_connect":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.connection.HTTPConnection._connect","name":"_connect","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["httpcore._sync.connection.HTTPConnection","httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_connect of HTTPConnection","ret_type":"httpcore._backends.base.NetworkStream","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_connect_failed":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._sync.connection.HTTPConnection._connect_failed","name":"_connect_failed","setter_type":null,"type":"builtins.bool"}},"_connection":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._sync.connection.HTTPConnection._connection","name":"_connection","setter_type":null,"type":{".class":"UnionType","items":["httpcore._sync.interfaces.ConnectionInterface",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_http1":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.connection.HTTPConnection._http1","name":"_http1","setter_type":null,"type":"builtins.bool"}},"_http2":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.connection.HTTPConnection._http2","name":"_http2","setter_type":null,"type":"builtins.bool"}},"_keepalive_expiry":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.connection.HTTPConnection._keepalive_expiry","name":"_keepalive_expiry","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_local_address":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.connection.HTTPConnection._local_address","name":"_local_address","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_network_backend":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._sync.connection.HTTPConnection._network_backend","name":"_network_backend","setter_type":null,"type":"httpcore._backends.base.NetworkBackend"}},"_origin":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.connection.HTTPConnection._origin","name":"_origin","setter_type":null,"type":"httpcore._models.Origin"}},"_request_lock":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.connection.HTTPConnection._request_lock","name":"_request_lock","setter_type":null,"type":"httpcore._synchronization.Lock"}},"_retries":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.connection.HTTPConnection._retries","name":"_retries","setter_type":null,"type":"builtins.int"}},"_socket_options":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.connection.HTTPConnection._socket_options","name":"_socket_options","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._backends.base.SOCKET_OPTION"}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_ssl_context":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.connection.HTTPConnection._ssl_context","name":"_ssl_context","setter_type":null,"type":{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_uds":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.connection.HTTPConnection._uds","name":"_uds","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"can_handle_request":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","origin"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.connection.HTTPConnection.can_handle_request","name":"can_handle_request","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","origin"],"arg_types":["httpcore._sync.connection.HTTPConnection","httpcore._models.Origin"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"can_handle_request of HTTPConnection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"close":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.connection.HTTPConnection.close","name":"close","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.connection.HTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"close of HTTPConnection","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"handle_request":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.connection.HTTPConnection.handle_request","name":"handle_request","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["httpcore._sync.connection.HTTPConnection","httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"handle_request of HTTPConnection","ret_type":"httpcore._models.Response","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"has_expired":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.connection.HTTPConnection.has_expired","name":"has_expired","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.connection.HTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"has_expired of HTTPConnection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"info":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.connection.HTTPConnection.info","name":"info","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.connection.HTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"info of HTTPConnection","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_available":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.connection.HTTPConnection.is_available","name":"is_available","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.connection.HTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_available of HTTPConnection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_closed":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.connection.HTTPConnection.is_closed","name":"is_closed","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.connection.HTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_closed of HTTPConnection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_idle":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.connection.HTTPConnection.is_idle","name":"is_idle","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.connection.HTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_idle of HTTPConnection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._sync.connection.HTTPConnection.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._sync.connection.HTTPConnection","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Lock":{".class":"SymbolTableNode","cross_ref":"httpcore._synchronization.Lock","kind":"Gdef"},"NetworkBackend":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.NetworkBackend","kind":"Gdef"},"NetworkStream":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.NetworkStream","kind":"Gdef"},"Origin":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Origin","kind":"Gdef"},"RETRIES_BACKOFF_FACTOR":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._sync.connection.RETRIES_BACKOFF_FACTOR","name":"RETRIES_BACKOFF_FACTOR","setter_type":null,"type":"builtins.float"}},"Request":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Request","kind":"Gdef"},"Response":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Response","kind":"Gdef"},"SOCKET_OPTION":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.SOCKET_OPTION","kind":"Gdef"},"SyncBackend":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.sync.SyncBackend","kind":"Gdef"},"Trace":{".class":"SymbolTableNode","cross_ref":"httpcore._trace.Trace","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.connection.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.connection.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.connection.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.connection.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.connection.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.connection.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"default_ssl_context":{".class":"SymbolTableNode","cross_ref":"httpcore._ssl.default_ssl_context","kind":"Gdef"},"exponential_backoff":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["factor"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"httpcore._sync.connection.exponential_backoff","name":"exponential_backoff","original_first_arg":"factor","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["factor"],"arg_types":["builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"exponential_backoff","ret_type":{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"typing.Iterator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"itertools":{".class":"SymbolTableNode","cross_ref":"itertools","kind":"Gdef"},"logger":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._sync.connection.logger","name":"logger","setter_type":null,"type":"logging.Logger"}},"logging":{".class":"SymbolTableNode","cross_ref":"logging","kind":"Gdef"},"ssl":{".class":"SymbolTableNode","cross_ref":"ssl","kind":"Gdef"},"types":{".class":"SymbolTableNode","cross_ref":"types","kind":"Gdef"},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_sync/connection.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/connection.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/connection.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..3921a103c012df6ce01b987a0134178c5ea6be72 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/connection.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[9,10,16,17,86,11,12,13,14,15,1,3,4,5,6,7,1,1,1,1,1],"dep_prios":[5,5,5,5,20,5,5,5,5,5,5,10,10,10,10,10,5,30,30,30,30],"dependencies":["httpcore._backends.sync","httpcore._backends.base","httpcore._sync.http11","httpcore._sync.interfaces","httpcore._sync.http2","httpcore._exceptions","httpcore._models","httpcore._ssl","httpcore._synchronization","httpcore._trace","__future__","itertools","logging","ssl","types","typing","builtins","_frozen_importlib","_ssl","abc","httpcore._backends"],"hash":"4424ca8b81314ccab4af4782c46c1560bcb983c7","id":"httpcore._sync.connection","ignore_all":true,"interface_hash":"f586de00d09d215bf2211c1cf95552f5deef273d","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_sync/connection.py","plugin_data":null,"size":8238,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/connection_pool.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/connection_pool.data.json new file mode 100644 index 0000000000000000000000000000000000000000..4e44b1d193e0d9b06a530518bc37c9a452e338ff --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/connection_pool.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"httpcore._sync.connection_pool","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","ConnectionInterface":{".class":"SymbolTableNode","cross_ref":"httpcore._sync.interfaces.ConnectionInterface","kind":"Gdef"},"ConnectionNotAvailable":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.ConnectionNotAvailable","kind":"Gdef"},"ConnectionPool":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["httpcore._sync.interfaces.RequestInterface"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._sync.connection_pool.ConnectionPool","name":"ConnectionPool","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._sync.connection_pool.ConnectionPool","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._sync.connection_pool","mro":["httpcore._sync.connection_pool.ConnectionPool","httpcore._sync.interfaces.RequestInterface","builtins.object"],"names":{".class":"SymbolTable","__enter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.connection_pool.ConnectionPool.__enter__","name":"__enter__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["httpcore._sync.connection_pool.ConnectionPool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__enter__ of ConnectionPool","ret_type":"httpcore._sync.connection_pool.ConnectionPool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__exit__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":[null,null,null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.connection_pool.ConnectionPool.__exit__","name":"__exit__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":[null,null,null,null],"arg_types":["httpcore._sync.connection_pool.ConnectionPool",{".class":"UnionType","items":[{".class":"TypeType","item":"builtins.BaseException"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.BaseException",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["types.TracebackType",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__exit__ of ConnectionPool","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1,1,1,1,1,1,1],"arg_names":["self","ssl_context","proxy","max_connections","max_keepalive_connections","keepalive_expiry","http1","http2","retries","local_address","uds","network_backend","socket_options"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.connection_pool.ConnectionPool.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,1,1,1,1,1,1],"arg_names":["self","ssl_context","proxy","max_connections","max_keepalive_connections","keepalive_expiry","http1","http2","retries","local_address","uds","network_backend","socket_options"],"arg_types":["httpcore._sync.connection_pool.ConnectionPool",{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["httpcore._models.Proxy",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool","builtins.int",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["httpcore._backends.base.NetworkBackend",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._backends.base.SOCKET_OPTION"}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of ConnectionPool","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.connection_pool.ConnectionPool.__repr__","name":"__repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["httpcore._sync.connection_pool.ConnectionPool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr__ of ConnectionPool","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_assign_requests_to_connections":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.connection_pool.ConnectionPool._assign_requests_to_connections","name":"_assign_requests_to_connections","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.connection_pool.ConnectionPool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_assign_requests_to_connections of ConnectionPool","ret_type":{".class":"Instance","args":["httpcore._sync.interfaces.ConnectionInterface"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_close_connections":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","closing"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.connection_pool.ConnectionPool._close_connections","name":"_close_connections","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","closing"],"arg_types":["httpcore._sync.connection_pool.ConnectionPool",{".class":"Instance","args":["httpcore._sync.interfaces.ConnectionInterface"],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_close_connections of ConnectionPool","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_connections":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._sync.connection_pool.ConnectionPool._connections","name":"_connections","setter_type":null,"type":{".class":"Instance","args":["httpcore._sync.interfaces.ConnectionInterface"],"extra_attrs":null,"type_ref":"builtins.list"}}},"_http1":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.connection_pool.ConnectionPool._http1","name":"_http1","setter_type":null,"type":"builtins.bool"}},"_http2":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.connection_pool.ConnectionPool._http2","name":"_http2","setter_type":null,"type":"builtins.bool"}},"_keepalive_expiry":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.connection_pool.ConnectionPool._keepalive_expiry","name":"_keepalive_expiry","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_local_address":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.connection_pool.ConnectionPool._local_address","name":"_local_address","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_max_connections":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.connection_pool.ConnectionPool._max_connections","name":"_max_connections","setter_type":null,"type":"builtins.int"}},"_max_keepalive_connections":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.connection_pool.ConnectionPool._max_keepalive_connections","name":"_max_keepalive_connections","setter_type":null,"type":"builtins.int"}},"_network_backend":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.connection_pool.ConnectionPool._network_backend","name":"_network_backend","setter_type":null,"type":"httpcore._backends.base.NetworkBackend"}},"_optional_thread_lock":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.connection_pool.ConnectionPool._optional_thread_lock","name":"_optional_thread_lock","setter_type":null,"type":"httpcore._synchronization.ThreadLock"}},"_proxy":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.connection_pool.ConnectionPool._proxy","name":"_proxy","setter_type":null,"type":{".class":"UnionType","items":["httpcore._models.Proxy",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_requests":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._sync.connection_pool.ConnectionPool._requests","name":"_requests","setter_type":null,"type":{".class":"Instance","args":["httpcore._sync.connection_pool.PoolRequest"],"extra_attrs":null,"type_ref":"builtins.list"}}},"_retries":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.connection_pool.ConnectionPool._retries","name":"_retries","setter_type":null,"type":"builtins.int"}},"_socket_options":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.connection_pool.ConnectionPool._socket_options","name":"_socket_options","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._backends.base.SOCKET_OPTION"}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_ssl_context":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.connection_pool.ConnectionPool._ssl_context","name":"_ssl_context","setter_type":null,"type":{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_uds":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.connection_pool.ConnectionPool._uds","name":"_uds","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"close":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.connection_pool.ConnectionPool.close","name":"close","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.connection_pool.ConnectionPool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"close of ConnectionPool","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"connections":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"httpcore._sync.connection_pool.ConnectionPool.connections","name":"connections","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.connection_pool.ConnectionPool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"connections of ConnectionPool","ret_type":{".class":"Instance","args":["httpcore._sync.interfaces.ConnectionInterface"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"httpcore._sync.connection_pool.ConnectionPool.connections","name":"connections","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.connection_pool.ConnectionPool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"connections of ConnectionPool","ret_type":{".class":"Instance","args":["httpcore._sync.interfaces.ConnectionInterface"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"create_connection":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","origin"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.connection_pool.ConnectionPool.create_connection","name":"create_connection","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","origin"],"arg_types":["httpcore._sync.connection_pool.ConnectionPool","httpcore._models.Origin"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"create_connection of ConnectionPool","ret_type":"httpcore._sync.interfaces.ConnectionInterface","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"handle_request":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.connection_pool.ConnectionPool.handle_request","name":"handle_request","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["httpcore._sync.connection_pool.ConnectionPool","httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"handle_request of ConnectionPool","ret_type":"httpcore._models.Response","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._sync.connection_pool.ConnectionPool.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._sync.connection_pool.ConnectionPool","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Event":{".class":"SymbolTableNode","cross_ref":"httpcore._synchronization.Event","kind":"Gdef"},"HTTPConnection":{".class":"SymbolTableNode","cross_ref":"httpcore._sync.connection.HTTPConnection","kind":"Gdef"},"NetworkBackend":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.NetworkBackend","kind":"Gdef"},"Origin":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Origin","kind":"Gdef"},"PoolByteStream":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._sync.connection_pool.PoolByteStream","name":"PoolByteStream","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._sync.connection_pool.PoolByteStream","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._sync.connection_pool","mro":["httpcore._sync.connection_pool.PoolByteStream","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","stream","pool_request","pool"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.connection_pool.PoolByteStream.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","stream","pool_request","pool"],"arg_types":["httpcore._sync.connection_pool.PoolByteStream",{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},"httpcore._sync.connection_pool.PoolRequest","httpcore._sync.connection_pool.ConnectionPool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of PoolByteStream","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__iter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.connection_pool.PoolByteStream.__iter__","name":"__iter__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["httpcore._sync.connection_pool.PoolByteStream"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iter__ of PoolByteStream","ret_type":{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_closed":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.connection_pool.PoolByteStream._closed","name":"_closed","setter_type":null,"type":"builtins.bool"}},"_pool":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.connection_pool.PoolByteStream._pool","name":"_pool","setter_type":null,"type":"httpcore._sync.connection_pool.ConnectionPool"}},"_pool_request":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.connection_pool.PoolByteStream._pool_request","name":"_pool_request","setter_type":null,"type":"httpcore._sync.connection_pool.PoolRequest"}},"_stream":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.connection_pool.PoolByteStream._stream","name":"_stream","setter_type":null,"type":{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"}}},"close":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.connection_pool.PoolByteStream.close","name":"close","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.connection_pool.PoolByteStream"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"close of PoolByteStream","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._sync.connection_pool.PoolByteStream.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._sync.connection_pool.PoolByteStream","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"PoolRequest":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._sync.connection_pool.PoolRequest","name":"PoolRequest","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._sync.connection_pool.PoolRequest","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._sync.connection_pool","mro":["httpcore._sync.connection_pool.PoolRequest","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.connection_pool.PoolRequest.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["httpcore._sync.connection_pool.PoolRequest","httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of PoolRequest","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_connection_acquired":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.connection_pool.PoolRequest._connection_acquired","name":"_connection_acquired","setter_type":null,"type":"httpcore._synchronization.Event"}},"assign_to_connection":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","connection"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.connection_pool.PoolRequest.assign_to_connection","name":"assign_to_connection","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","connection"],"arg_types":["httpcore._sync.connection_pool.PoolRequest",{".class":"UnionType","items":["httpcore._sync.interfaces.ConnectionInterface",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assign_to_connection of PoolRequest","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"clear_connection":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.connection_pool.PoolRequest.clear_connection","name":"clear_connection","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.connection_pool.PoolRequest"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"clear_connection of PoolRequest","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"connection":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._sync.connection_pool.PoolRequest.connection","name":"connection","setter_type":null,"type":{".class":"UnionType","items":["httpcore._sync.interfaces.ConnectionInterface",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"is_queued":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.connection_pool.PoolRequest.is_queued","name":"is_queued","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.connection_pool.PoolRequest"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_queued of PoolRequest","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"request":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.connection_pool.PoolRequest.request","name":"request","setter_type":null,"type":"httpcore._models.Request"}},"wait_for_connection":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.connection_pool.PoolRequest.wait_for_connection","name":"wait_for_connection","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","timeout"],"arg_types":["httpcore._sync.connection_pool.PoolRequest",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"wait_for_connection of PoolRequest","ret_type":"httpcore._sync.interfaces.ConnectionInterface","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._sync.connection_pool.PoolRequest.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._sync.connection_pool.PoolRequest","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Proxy":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Proxy","kind":"Gdef"},"Request":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Request","kind":"Gdef"},"RequestInterface":{".class":"SymbolTableNode","cross_ref":"httpcore._sync.interfaces.RequestInterface","kind":"Gdef"},"Response":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Response","kind":"Gdef"},"SOCKET_OPTION":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.SOCKET_OPTION","kind":"Gdef"},"ShieldCancellation":{".class":"SymbolTableNode","cross_ref":"httpcore._synchronization.ShieldCancellation","kind":"Gdef"},"SyncBackend":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.sync.SyncBackend","kind":"Gdef"},"ThreadLock":{".class":"SymbolTableNode","cross_ref":"httpcore._synchronization.ThreadLock","kind":"Gdef"},"UnsupportedProtocol":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.UnsupportedProtocol","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.connection_pool.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.connection_pool.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.connection_pool.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.connection_pool.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.connection_pool.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.connection_pool.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"ssl":{".class":"SymbolTableNode","cross_ref":"ssl","kind":"Gdef"},"sys":{".class":"SymbolTableNode","cross_ref":"sys","kind":"Gdef"},"types":{".class":"SymbolTableNode","cross_ref":"types","kind":"Gdef"},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_sync/connection_pool.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/connection_pool.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/connection_pool.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..be0fe8529ac7890fe1f0523645a511d58a37f284 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/connection_pool.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[8,9,13,14,131,144,10,11,12,1,3,4,5,6,1,1,1,1,1,1],"dep_prios":[5,5,5,5,20,20,5,5,5,5,10,10,10,10,5,30,30,30,30,30],"dependencies":["httpcore._backends.sync","httpcore._backends.base","httpcore._sync.connection","httpcore._sync.interfaces","httpcore._sync.socks_proxy","httpcore._sync.http_proxy","httpcore._exceptions","httpcore._models","httpcore._synchronization","__future__","ssl","sys","types","typing","builtins","_frozen_importlib","_ssl","_typeshed","abc","httpcore._backends"],"hash":"a4fa103de61479074f51e3c33f787c950ce05b80","id":"httpcore._sync.connection_pool","ignore_all":true,"interface_hash":"7e7d02ee2d737695b636c3b8c6b0e7988e1533a3","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_sync/connection_pool.py","plugin_data":null,"size":16955,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/http11.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/http11.data.json new file mode 100644 index 0000000000000000000000000000000000000000..fc1d247ff3f6ccedb419e3858ed79c7b4c2b5793 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/http11.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"httpcore._sync.http11","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","ConnectionInterface":{".class":"SymbolTableNode","cross_ref":"httpcore._sync.interfaces.ConnectionInterface","kind":"Gdef"},"ConnectionNotAvailable":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.ConnectionNotAvailable","kind":"Gdef"},"H11SendEvent":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"httpcore._sync.http11.H11SendEvent","line":29,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["h11._events.Request","h11._events.Data","h11._events.EndOfMessage"],"uses_pep604_syntax":false}}},"HTTP11Connection":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["httpcore._sync.interfaces.ConnectionInterface"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._sync.http11.HTTP11Connection","name":"HTTP11Connection","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._sync.http11.HTTP11Connection","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._sync.http11","mro":["httpcore._sync.http11.HTTP11Connection","httpcore._sync.interfaces.ConnectionInterface","httpcore._sync.interfaces.RequestInterface","builtins.object"],"names":{".class":"SymbolTable","MAX_INCOMPLETE_EVENT_SIZE":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._sync.http11.HTTP11Connection.MAX_INCOMPLETE_EVENT_SIZE","name":"MAX_INCOMPLETE_EVENT_SIZE","setter_type":null,"type":"builtins.int"}},"READ_NUM_BYTES":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._sync.http11.HTTP11Connection.READ_NUM_BYTES","name":"READ_NUM_BYTES","setter_type":null,"type":"builtins.int"}},"__enter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http11.HTTP11Connection.__enter__","name":"__enter__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["httpcore._sync.http11.HTTP11Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__enter__ of HTTP11Connection","ret_type":"httpcore._sync.http11.HTTP11Connection","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__exit__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":[null,null,null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http11.HTTP11Connection.__exit__","name":"__exit__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":[null,null,null,null],"arg_types":["httpcore._sync.http11.HTTP11Connection",{".class":"UnionType","items":[{".class":"TypeType","item":"builtins.BaseException"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.BaseException",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["types.TracebackType",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__exit__ of HTTP11Connection","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","origin","stream","keepalive_expiry"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http11.HTTP11Connection.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","origin","stream","keepalive_expiry"],"arg_types":["httpcore._sync.http11.HTTP11Connection","httpcore._models.Origin","httpcore._backends.base.NetworkStream",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of HTTP11Connection","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http11.HTTP11Connection.__repr__","name":"__repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["httpcore._sync.http11.HTTP11Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr__ of HTTP11Connection","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_expire_at":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._sync.http11.HTTP11Connection._expire_at","name":"_expire_at","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_h11_state":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http11.HTTP11Connection._h11_state","name":"_h11_state","setter_type":null,"type":"h11._connection.Connection"}},"_keepalive_expiry":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._sync.http11.HTTP11Connection._keepalive_expiry","name":"_keepalive_expiry","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_network_stream":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http11.HTTP11Connection._network_stream","name":"_network_stream","setter_type":null,"type":"httpcore._backends.base.NetworkStream"}},"_origin":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http11.HTTP11Connection._origin","name":"_origin","setter_type":null,"type":"httpcore._models.Origin"}},"_receive_event":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http11.HTTP11Connection._receive_event","name":"_receive_event","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","timeout"],"arg_types":["httpcore._sync.http11.HTTP11Connection",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_receive_event of HTTP11Connection","ret_type":{".class":"UnionType","items":["h11._events.Event",{".class":"TypeType","item":"h11._connection.PAUSED"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_receive_response_body":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http11.HTTP11Connection._receive_response_body","name":"_receive_response_body","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["httpcore._sync.http11.HTTP11Connection","httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_receive_response_body of HTTP11Connection","ret_type":{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_receive_response_headers":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http11.HTTP11Connection._receive_response_headers","name":"_receive_response_headers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["httpcore._sync.http11.HTTP11Connection","httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_receive_response_headers of HTTP11Connection","ret_type":{".class":"TupleType","implicit":false,"items":["builtins.bytes","builtins.int","builtins.bytes",{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.bytes","builtins.bytes"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"builtins.list"},"builtins.bytes"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_request_count":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http11.HTTP11Connection._request_count","name":"_request_count","setter_type":null,"type":"builtins.int"}},"_response_closed":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http11.HTTP11Connection._response_closed","name":"_response_closed","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.http11.HTTP11Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_response_closed of HTTP11Connection","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_send_event":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","event","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http11.HTTP11Connection._send_event","name":"_send_event","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","event","timeout"],"arg_types":["httpcore._sync.http11.HTTP11Connection","h11._events.Event",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_send_event of HTTP11Connection","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_send_request_body":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http11.HTTP11Connection._send_request_body","name":"_send_request_body","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["httpcore._sync.http11.HTTP11Connection","httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_send_request_body of HTTP11Connection","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_send_request_headers":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http11.HTTP11Connection._send_request_headers","name":"_send_request_headers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["httpcore._sync.http11.HTTP11Connection","httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_send_request_headers of HTTP11Connection","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_state":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http11.HTTP11Connection._state","name":"_state","setter_type":null,"type":"httpcore._sync.http11.HTTPConnectionState"}},"_state_lock":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http11.HTTP11Connection._state_lock","name":"_state_lock","setter_type":null,"type":"httpcore._synchronization.Lock"}},"can_handle_request":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","origin"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http11.HTTP11Connection.can_handle_request","name":"can_handle_request","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","origin"],"arg_types":["httpcore._sync.http11.HTTP11Connection","httpcore._models.Origin"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"can_handle_request of HTTP11Connection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"close":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http11.HTTP11Connection.close","name":"close","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.http11.HTTP11Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"close of HTTP11Connection","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"handle_request":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http11.HTTP11Connection.handle_request","name":"handle_request","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["httpcore._sync.http11.HTTP11Connection","httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"handle_request of HTTP11Connection","ret_type":"httpcore._models.Response","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"has_expired":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http11.HTTP11Connection.has_expired","name":"has_expired","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.http11.HTTP11Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"has_expired of HTTP11Connection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"info":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http11.HTTP11Connection.info","name":"info","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.http11.HTTP11Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"info of HTTP11Connection","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_available":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http11.HTTP11Connection.is_available","name":"is_available","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.http11.HTTP11Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_available of HTTP11Connection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_closed":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http11.HTTP11Connection.is_closed","name":"is_closed","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.http11.HTTP11Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_closed of HTTP11Connection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_idle":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http11.HTTP11Connection.is_idle","name":"is_idle","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.http11.HTTP11Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_idle of HTTP11Connection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._sync.http11.HTTP11Connection.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._sync.http11.HTTP11Connection","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"HTTP11ConnectionByteStream":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._sync.http11.HTTP11ConnectionByteStream","name":"HTTP11ConnectionByteStream","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._sync.http11.HTTP11ConnectionByteStream","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._sync.http11","mro":["httpcore._sync.http11.HTTP11ConnectionByteStream","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","connection","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http11.HTTP11ConnectionByteStream.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","connection","request"],"arg_types":["httpcore._sync.http11.HTTP11ConnectionByteStream","httpcore._sync.http11.HTTP11Connection","httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of HTTP11ConnectionByteStream","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__iter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http11.HTTP11ConnectionByteStream.__iter__","name":"__iter__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["httpcore._sync.http11.HTTP11ConnectionByteStream"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iter__ of HTTP11ConnectionByteStream","ret_type":{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_closed":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http11.HTTP11ConnectionByteStream._closed","name":"_closed","setter_type":null,"type":"builtins.bool"}},"_connection":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http11.HTTP11ConnectionByteStream._connection","name":"_connection","setter_type":null,"type":"httpcore._sync.http11.HTTP11Connection"}},"_request":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http11.HTTP11ConnectionByteStream._request","name":"_request","setter_type":null,"type":"httpcore._models.Request"}},"close":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http11.HTTP11ConnectionByteStream.close","name":"close","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.http11.HTTP11ConnectionByteStream"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"close of HTTP11ConnectionByteStream","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._sync.http11.HTTP11ConnectionByteStream.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._sync.http11.HTTP11ConnectionByteStream","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"HTTP11UpgradeStream":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["httpcore._backends.base.NetworkStream"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._sync.http11.HTTP11UpgradeStream","name":"HTTP11UpgradeStream","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._sync.http11.HTTP11UpgradeStream","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._sync.http11","mro":["httpcore._sync.http11.HTTP11UpgradeStream","httpcore._backends.base.NetworkStream","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","stream","leading_data"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http11.HTTP11UpgradeStream.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","stream","leading_data"],"arg_types":["httpcore._sync.http11.HTTP11UpgradeStream","httpcore._backends.base.NetworkStream","builtins.bytes"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of HTTP11UpgradeStream","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_leading_data":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http11.HTTP11UpgradeStream._leading_data","name":"_leading_data","setter_type":null,"type":"builtins.bytes"}},"_stream":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http11.HTTP11UpgradeStream._stream","name":"_stream","setter_type":null,"type":"httpcore._backends.base.NetworkStream"}},"close":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http11.HTTP11UpgradeStream.close","name":"close","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.http11.HTTP11UpgradeStream"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"close of HTTP11UpgradeStream","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_extra_info":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http11.HTTP11UpgradeStream.get_extra_info","name":"get_extra_info","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","info"],"arg_types":["httpcore._sync.http11.HTTP11UpgradeStream","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_extra_info of HTTP11UpgradeStream","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"read":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","max_bytes","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http11.HTTP11UpgradeStream.read","name":"read","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","max_bytes","timeout"],"arg_types":["httpcore._sync.http11.HTTP11UpgradeStream","builtins.int",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"read of HTTP11UpgradeStream","ret_type":"builtins.bytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"start_tls":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","ssl_context","server_hostname","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http11.HTTP11UpgradeStream.start_tls","name":"start_tls","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","ssl_context","server_hostname","timeout"],"arg_types":["httpcore._sync.http11.HTTP11UpgradeStream","ssl.SSLContext",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"start_tls of HTTP11UpgradeStream","ret_type":"httpcore._backends.base.NetworkStream","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"write":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","buffer","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http11.HTTP11UpgradeStream.write","name":"write","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","buffer","timeout"],"arg_types":["httpcore._sync.http11.HTTP11UpgradeStream","builtins.bytes",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"write of HTTP11UpgradeStream","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._sync.http11.HTTP11UpgradeStream.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._sync.http11.HTTP11UpgradeStream","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"HTTPConnectionState":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["enum.IntEnum"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._sync.http11.HTTPConnectionState","name":"HTTPConnectionState","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_enum"],"fullname":"httpcore._sync.http11.HTTPConnectionState","has_param_spec_type":false,"metaclass_type":"enum.EnumMeta","metadata":{},"module_name":"httpcore._sync.http11","mro":["httpcore._sync.http11.HTTPConnectionState","enum.IntEnum","builtins.int","enum.Enum","builtins.object"],"names":{".class":"SymbolTable","ACTIVE":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._sync.http11.HTTPConnectionState.ACTIVE","name":"ACTIVE","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.int","value":1},"type_ref":"builtins.int"}}},"CLOSED":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._sync.http11.HTTPConnectionState.CLOSED","name":"CLOSED","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.int","value":3},"type_ref":"builtins.int"}}},"IDLE":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._sync.http11.HTTPConnectionState.IDLE","name":"IDLE","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.int","value":2},"type_ref":"builtins.int"}}},"NEW":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._sync.http11.HTTPConnectionState.NEW","name":"NEW","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.int","value":0},"type_ref":"builtins.int"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._sync.http11.HTTPConnectionState.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._sync.http11.HTTPConnectionState","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"LocalProtocolError":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.LocalProtocolError","kind":"Gdef"},"Lock":{".class":"SymbolTableNode","cross_ref":"httpcore._synchronization.Lock","kind":"Gdef"},"NetworkStream":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.NetworkStream","kind":"Gdef"},"Origin":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Origin","kind":"Gdef"},"RemoteProtocolError":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.RemoteProtocolError","kind":"Gdef"},"Request":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Request","kind":"Gdef"},"Response":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Response","kind":"Gdef"},"ShieldCancellation":{".class":"SymbolTableNode","cross_ref":"httpcore._synchronization.ShieldCancellation","kind":"Gdef"},"Trace":{".class":"SymbolTableNode","cross_ref":"httpcore._trace.Trace","kind":"Gdef"},"WriteError":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.WriteError","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.http11.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.http11.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.http11.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.http11.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.http11.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.http11.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"enum":{".class":"SymbolTableNode","cross_ref":"enum","kind":"Gdef"},"h11":{".class":"SymbolTableNode","cross_ref":"h11","kind":"Gdef"},"logger":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._sync.http11.logger","name":"logger","setter_type":null,"type":"logging.Logger"}},"logging":{".class":"SymbolTableNode","cross_ref":"logging","kind":"Gdef"},"map_exceptions":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.map_exceptions","kind":"Gdef"},"ssl":{".class":"SymbolTableNode","cross_ref":"ssl","kind":"Gdef"},"time":{".class":"SymbolTableNode","cross_ref":"time","kind":"Gdef"},"types":{".class":"SymbolTableNode","cross_ref":"types","kind":"Gdef"},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_sync/http11.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/http11.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/http11.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..5558260be6f8ca3843a4e68a2524be67782a5d6a --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/http11.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[12,23,13,20,21,22,1,3,4,5,6,7,8,10,1,1,1,1,1,1,1,1,1],"dep_prios":[5,5,5,5,5,5,5,10,10,10,10,10,10,10,5,30,30,30,30,30,30,30,30],"dependencies":["httpcore._backends.base","httpcore._sync.interfaces","httpcore._exceptions","httpcore._models","httpcore._synchronization","httpcore._trace","__future__","enum","logging","ssl","time","types","typing","h11","builtins","_frozen_importlib","_ssl","abc","h11._connection","h11._events","h11._state","h11._util","httpcore._backends"],"hash":"8a1ad13f707fa882ff89d94469e0915d74dc9431","id":"httpcore._sync.http11","ignore_all":true,"interface_hash":"4377cec9e7ff97550890bdc4705d91d39b96645f","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_sync/http11.py","plugin_data":null,"size":13476,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/http2.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/http2.data.json new file mode 100644 index 0000000000000000000000000000000000000000..1b92e2cd49e4e059426c7db9f70952858622dbc1 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/http2.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"httpcore._sync.http2","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","ConnectionInterface":{".class":"SymbolTableNode","cross_ref":"httpcore._sync.interfaces.ConnectionInterface","kind":"Gdef"},"ConnectionNotAvailable":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.ConnectionNotAvailable","kind":"Gdef"},"HTTP2Connection":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["httpcore._sync.interfaces.ConnectionInterface"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._sync.http2.HTTP2Connection","name":"HTTP2Connection","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._sync.http2.HTTP2Connection","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._sync.http2","mro":["httpcore._sync.http2.HTTP2Connection","httpcore._sync.interfaces.ConnectionInterface","httpcore._sync.interfaces.RequestInterface","builtins.object"],"names":{".class":"SymbolTable","CONFIG":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._sync.http2.HTTP2Connection.CONFIG","name":"CONFIG","setter_type":null,"type":{".class":"AnyType","missing_import_name":"httpcore._sync.http2.h2","source_any":{".class":"AnyType","missing_import_name":"httpcore._sync.http2.h2","source_any":null,"type_of_any":3},"type_of_any":7}}},"READ_NUM_BYTES":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._sync.http2.HTTP2Connection.READ_NUM_BYTES","name":"READ_NUM_BYTES","setter_type":null,"type":"builtins.int"}},"__enter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http2.HTTP2Connection.__enter__","name":"__enter__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["httpcore._sync.http2.HTTP2Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__enter__ of HTTP2Connection","ret_type":"httpcore._sync.http2.HTTP2Connection","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__exit__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":[null,null,null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http2.HTTP2Connection.__exit__","name":"__exit__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":[null,null,null,null],"arg_types":["httpcore._sync.http2.HTTP2Connection",{".class":"UnionType","items":[{".class":"TypeType","item":"builtins.BaseException"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.BaseException",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["types.TracebackType",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__exit__ of HTTP2Connection","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","origin","stream","keepalive_expiry"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http2.HTTP2Connection.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","origin","stream","keepalive_expiry"],"arg_types":["httpcore._sync.http2.HTTP2Connection","httpcore._models.Origin","httpcore._backends.base.NetworkStream",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of HTTP2Connection","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http2.HTTP2Connection.__repr__","name":"__repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["httpcore._sync.http2.HTTP2Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr__ of HTTP2Connection","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_connection_error":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http2.HTTP2Connection._connection_error","name":"_connection_error","setter_type":null,"type":"builtins.bool"}},"_connection_terminated":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._sync.http2.HTTP2Connection._connection_terminated","name":"_connection_terminated","setter_type":null,"type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"httpcore._sync.http2.h2","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_events":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._sync.http2.HTTP2Connection._events","name":"_events","setter_type":null,"type":{".class":"Instance","args":["builtins.int",{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"httpcore._sync.http2.h2","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"httpcore._sync.http2.h2","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"httpcore._sync.http2.h2","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"httpcore._sync.http2.h2","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_expire_at":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._sync.http2.HTTP2Connection._expire_at","name":"_expire_at","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_h2_state":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http2.HTTP2Connection._h2_state","name":"_h2_state","setter_type":null,"type":{".class":"AnyType","missing_import_name":"httpcore._sync.http2.h2","source_any":{".class":"AnyType","missing_import_name":"httpcore._sync.http2.h2","source_any":null,"type_of_any":3},"type_of_any":7}}},"_init_lock":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http2.HTTP2Connection._init_lock","name":"_init_lock","setter_type":null,"type":"httpcore._synchronization.Lock"}},"_keepalive_expiry":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._sync.http2.HTTP2Connection._keepalive_expiry","name":"_keepalive_expiry","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_max_streams":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http2.HTTP2Connection._max_streams","name":"_max_streams","setter_type":null,"type":"builtins.int"}},"_max_streams_semaphore":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http2.HTTP2Connection._max_streams_semaphore","name":"_max_streams_semaphore","setter_type":null,"type":"httpcore._synchronization.Semaphore"}},"_network_stream":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http2.HTTP2Connection._network_stream","name":"_network_stream","setter_type":null,"type":"httpcore._backends.base.NetworkStream"}},"_origin":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http2.HTTP2Connection._origin","name":"_origin","setter_type":null,"type":"httpcore._models.Origin"}},"_read_exception":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._sync.http2.HTTP2Connection._read_exception","name":"_read_exception","setter_type":null,"type":{".class":"UnionType","items":["builtins.Exception",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_read_incoming_data":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http2.HTTP2Connection._read_incoming_data","name":"_read_incoming_data","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["httpcore._sync.http2.HTTP2Connection","httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_read_incoming_data of HTTP2Connection","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"httpcore._sync.http2.h2","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_read_lock":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http2.HTTP2Connection._read_lock","name":"_read_lock","setter_type":null,"type":"httpcore._synchronization.Lock"}},"_receive_events":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","request","stream_id"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http2.HTTP2Connection._receive_events","name":"_receive_events","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","request","stream_id"],"arg_types":["httpcore._sync.http2.HTTP2Connection","httpcore._models.Request",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_receive_events of HTTP2Connection","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_receive_remote_settings_change":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","event"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http2.HTTP2Connection._receive_remote_settings_change","name":"_receive_remote_settings_change","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","event"],"arg_types":["httpcore._sync.http2.HTTP2Connection",{".class":"AnyType","missing_import_name":"httpcore._sync.http2.h2","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_receive_remote_settings_change of HTTP2Connection","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_receive_response":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","request","stream_id"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http2.HTTP2Connection._receive_response","name":"_receive_response","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","request","stream_id"],"arg_types":["httpcore._sync.http2.HTTP2Connection","httpcore._models.Request","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_receive_response of HTTP2Connection","ret_type":{".class":"TupleType","implicit":false,"items":["builtins.int",{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.bytes","builtins.bytes"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"builtins.list"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_receive_response_body":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","request","stream_id"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http2.HTTP2Connection._receive_response_body","name":"_receive_response_body","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","request","stream_id"],"arg_types":["httpcore._sync.http2.HTTP2Connection","httpcore._models.Request","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_receive_response_body of HTTP2Connection","ret_type":{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_receive_stream_event":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","request","stream_id"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http2.HTTP2Connection._receive_stream_event","name":"_receive_stream_event","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","request","stream_id"],"arg_types":["httpcore._sync.http2.HTTP2Connection","httpcore._models.Request","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_receive_stream_event of HTTP2Connection","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"httpcore._sync.http2.h2","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"httpcore._sync.http2.h2","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"httpcore._sync.http2.h2","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_request_count":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http2.HTTP2Connection._request_count","name":"_request_count","setter_type":null,"type":"builtins.int"}},"_response_closed":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","stream_id"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http2.HTTP2Connection._response_closed","name":"_response_closed","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","stream_id"],"arg_types":["httpcore._sync.http2.HTTP2Connection","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_response_closed of HTTP2Connection","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_send_connection_init":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http2.HTTP2Connection._send_connection_init","name":"_send_connection_init","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["httpcore._sync.http2.HTTP2Connection","httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_send_connection_init of HTTP2Connection","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_send_end_stream":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","request","stream_id"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http2.HTTP2Connection._send_end_stream","name":"_send_end_stream","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","request","stream_id"],"arg_types":["httpcore._sync.http2.HTTP2Connection","httpcore._models.Request","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_send_end_stream of HTTP2Connection","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_send_request_body":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","request","stream_id"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http2.HTTP2Connection._send_request_body","name":"_send_request_body","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","request","stream_id"],"arg_types":["httpcore._sync.http2.HTTP2Connection","httpcore._models.Request","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_send_request_body of HTTP2Connection","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_send_request_headers":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","request","stream_id"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http2.HTTP2Connection._send_request_headers","name":"_send_request_headers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","request","stream_id"],"arg_types":["httpcore._sync.http2.HTTP2Connection","httpcore._models.Request","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_send_request_headers of HTTP2Connection","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_send_stream_data":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","request","stream_id","data"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http2.HTTP2Connection._send_stream_data","name":"_send_stream_data","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","request","stream_id","data"],"arg_types":["httpcore._sync.http2.HTTP2Connection","httpcore._models.Request","builtins.int","builtins.bytes"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_send_stream_data of HTTP2Connection","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_sent_connection_init":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http2.HTTP2Connection._sent_connection_init","name":"_sent_connection_init","setter_type":null,"type":"builtins.bool"}},"_state":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http2.HTTP2Connection._state","name":"_state","setter_type":null,"type":"httpcore._sync.http2.HTTPConnectionState"}},"_state_lock":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http2.HTTP2Connection._state_lock","name":"_state_lock","setter_type":null,"type":"httpcore._synchronization.Lock"}},"_used_all_stream_ids":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http2.HTTP2Connection._used_all_stream_ids","name":"_used_all_stream_ids","setter_type":null,"type":"builtins.bool"}},"_wait_for_outgoing_flow":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","request","stream_id"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http2.HTTP2Connection._wait_for_outgoing_flow","name":"_wait_for_outgoing_flow","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","request","stream_id"],"arg_types":["httpcore._sync.http2.HTTP2Connection","httpcore._models.Request","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_wait_for_outgoing_flow of HTTP2Connection","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_write_exception":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._sync.http2.HTTP2Connection._write_exception","name":"_write_exception","setter_type":null,"type":{".class":"UnionType","items":["builtins.Exception",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_write_lock":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http2.HTTP2Connection._write_lock","name":"_write_lock","setter_type":null,"type":"httpcore._synchronization.Lock"}},"_write_outgoing_data":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http2.HTTP2Connection._write_outgoing_data","name":"_write_outgoing_data","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["httpcore._sync.http2.HTTP2Connection","httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_write_outgoing_data of HTTP2Connection","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"can_handle_request":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","origin"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http2.HTTP2Connection.can_handle_request","name":"can_handle_request","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","origin"],"arg_types":["httpcore._sync.http2.HTTP2Connection","httpcore._models.Origin"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"can_handle_request of HTTP2Connection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"close":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http2.HTTP2Connection.close","name":"close","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.http2.HTTP2Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"close of HTTP2Connection","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"handle_request":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http2.HTTP2Connection.handle_request","name":"handle_request","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["httpcore._sync.http2.HTTP2Connection","httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"handle_request of HTTP2Connection","ret_type":"httpcore._models.Response","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"has_expired":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http2.HTTP2Connection.has_expired","name":"has_expired","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.http2.HTTP2Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"has_expired of HTTP2Connection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"info":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http2.HTTP2Connection.info","name":"info","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.http2.HTTP2Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"info of HTTP2Connection","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_available":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http2.HTTP2Connection.is_available","name":"is_available","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.http2.HTTP2Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_available of HTTP2Connection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_closed":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http2.HTTP2Connection.is_closed","name":"is_closed","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.http2.HTTP2Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_closed of HTTP2Connection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_idle":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http2.HTTP2Connection.is_idle","name":"is_idle","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.http2.HTTP2Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_idle of HTTP2Connection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._sync.http2.HTTP2Connection.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._sync.http2.HTTP2Connection","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"HTTP2ConnectionByteStream":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._sync.http2.HTTP2ConnectionByteStream","name":"HTTP2ConnectionByteStream","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._sync.http2.HTTP2ConnectionByteStream","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._sync.http2","mro":["httpcore._sync.http2.HTTP2ConnectionByteStream","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","connection","request","stream_id"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http2.HTTP2ConnectionByteStream.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","connection","request","stream_id"],"arg_types":["httpcore._sync.http2.HTTP2ConnectionByteStream","httpcore._sync.http2.HTTP2Connection","httpcore._models.Request","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of HTTP2ConnectionByteStream","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__iter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http2.HTTP2ConnectionByteStream.__iter__","name":"__iter__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["httpcore._sync.http2.HTTP2ConnectionByteStream"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iter__ of HTTP2ConnectionByteStream","ret_type":{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_closed":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http2.HTTP2ConnectionByteStream._closed","name":"_closed","setter_type":null,"type":"builtins.bool"}},"_connection":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http2.HTTP2ConnectionByteStream._connection","name":"_connection","setter_type":null,"type":"httpcore._sync.http2.HTTP2Connection"}},"_request":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http2.HTTP2ConnectionByteStream._request","name":"_request","setter_type":null,"type":"httpcore._models.Request"}},"_stream_id":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http2.HTTP2ConnectionByteStream._stream_id","name":"_stream_id","setter_type":null,"type":"builtins.int"}},"close":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http2.HTTP2ConnectionByteStream.close","name":"close","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.http2.HTTP2ConnectionByteStream"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"close of HTTP2ConnectionByteStream","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._sync.http2.HTTP2ConnectionByteStream.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._sync.http2.HTTP2ConnectionByteStream","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"HTTPConnectionState":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["enum.IntEnum"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._sync.http2.HTTPConnectionState","name":"HTTPConnectionState","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_enum"],"fullname":"httpcore._sync.http2.HTTPConnectionState","has_param_spec_type":false,"metaclass_type":"enum.EnumMeta","metadata":{},"module_name":"httpcore._sync.http2","mro":["httpcore._sync.http2.HTTPConnectionState","enum.IntEnum","builtins.int","enum.Enum","builtins.object"],"names":{".class":"SymbolTable","ACTIVE":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._sync.http2.HTTPConnectionState.ACTIVE","name":"ACTIVE","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.int","value":1},"type_ref":"builtins.int"}}},"CLOSED":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._sync.http2.HTTPConnectionState.CLOSED","name":"CLOSED","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.int","value":3},"type_ref":"builtins.int"}}},"IDLE":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._sync.http2.HTTPConnectionState.IDLE","name":"IDLE","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.int","value":2},"type_ref":"builtins.int"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._sync.http2.HTTPConnectionState.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._sync.http2.HTTPConnectionState","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"LocalProtocolError":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.LocalProtocolError","kind":"Gdef"},"Lock":{".class":"SymbolTableNode","cross_ref":"httpcore._synchronization.Lock","kind":"Gdef"},"NetworkStream":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.NetworkStream","kind":"Gdef"},"Origin":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Origin","kind":"Gdef"},"RemoteProtocolError":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.RemoteProtocolError","kind":"Gdef"},"Request":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Request","kind":"Gdef"},"Response":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Response","kind":"Gdef"},"Semaphore":{".class":"SymbolTableNode","cross_ref":"httpcore._synchronization.Semaphore","kind":"Gdef"},"ShieldCancellation":{".class":"SymbolTableNode","cross_ref":"httpcore._synchronization.ShieldCancellation","kind":"Gdef"},"Trace":{".class":"SymbolTableNode","cross_ref":"httpcore._trace.Trace","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.http2.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.http2.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.http2.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.http2.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.http2.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.http2.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"enum":{".class":"SymbolTableNode","cross_ref":"enum","kind":"Gdef"},"h2":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"httpcore._sync.http2.h2","name":"h2","setter_type":null,"type":{".class":"AnyType","missing_import_name":"httpcore._sync.http2.h2","source_any":null,"type_of_any":3}}},"has_body_headers":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["request"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"httpcore._sync.http2.has_body_headers","name":"has_body_headers","original_first_arg":"request","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["request"],"arg_types":["httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"has_body_headers","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"logger":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._sync.http2.logger","name":"logger","setter_type":null,"type":"logging.Logger"}},"logging":{".class":"SymbolTableNode","cross_ref":"logging","kind":"Gdef"},"time":{".class":"SymbolTableNode","cross_ref":"time","kind":"Gdef"},"types":{".class":"SymbolTableNode","cross_ref":"types","kind":"Gdef"},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_sync/http2.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/http2.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/http2.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..ad60808684138dcd6dd9ce17ff51753483e428e3 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/http2.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[15,24,16,21,22,23,1,3,4,5,6,7,1,1,1,1,9,10,11,12,13,9],"dep_prios":[5,5,5,5,5,5,5,10,10,10,10,10,5,30,30,30,10,10,10,10,10,20],"dependencies":["httpcore._backends.base","httpcore._sync.interfaces","httpcore._exceptions","httpcore._models","httpcore._synchronization","httpcore._trace","__future__","enum","logging","time","types","typing","builtins","_frozen_importlib","abc","httpcore._backends"],"hash":"b9c5b753ec35143611909ab8872d7b45a610158d","id":"httpcore._sync.http2","ignore_all":true,"interface_hash":"90f052bafeb9ee958239aff19bd8a64b3d89bdc0","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_sync/http2.py","plugin_data":null,"size":23400,"suppressed":["h2.config","h2.connection","h2.events","h2.exceptions","h2.settings","h2"],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/http_proxy.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/http_proxy.data.json new file mode 100644 index 0000000000000000000000000000000000000000..7ea62e421f29a74ad759b404730ece1708069452 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/http_proxy.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"httpcore._sync.http_proxy","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","ByteOrStr":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"httpcore._sync.http_proxy.ByteOrStr","line":27,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["builtins.bytes","builtins.str"],"uses_pep604_syntax":false}}},"ConnectionInterface":{".class":"SymbolTableNode","cross_ref":"httpcore._sync.interfaces.ConnectionInterface","kind":"Gdef"},"ConnectionPool":{".class":"SymbolTableNode","cross_ref":"httpcore._sync.connection_pool.ConnectionPool","kind":"Gdef"},"ForwardHTTPConnection":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["httpcore._sync.interfaces.ConnectionInterface"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._sync.http_proxy.ForwardHTTPConnection","name":"ForwardHTTPConnection","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._sync.http_proxy.ForwardHTTPConnection","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._sync.http_proxy","mro":["httpcore._sync.http_proxy.ForwardHTTPConnection","httpcore._sync.interfaces.ConnectionInterface","httpcore._sync.interfaces.RequestInterface","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1,1,1],"arg_names":["self","proxy_origin","remote_origin","proxy_headers","keepalive_expiry","network_backend","socket_options","proxy_ssl_context"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http_proxy.ForwardHTTPConnection.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1,1],"arg_names":["self","proxy_origin","remote_origin","proxy_headers","keepalive_expiry","network_backend","socket_options","proxy_ssl_context"],"arg_types":["httpcore._sync.http_proxy.ForwardHTTPConnection","httpcore._models.Origin","httpcore._models.Origin",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._sync.http_proxy.HeadersAsMapping"},{".class":"TypeAliasType","args":[],"type_ref":"httpcore._sync.http_proxy.HeadersAsSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["httpcore._backends.base.NetworkBackend",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._backends.base.SOCKET_OPTION"}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of ForwardHTTPConnection","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http_proxy.ForwardHTTPConnection.__repr__","name":"__repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["httpcore._sync.http_proxy.ForwardHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr__ of ForwardHTTPConnection","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_connection":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http_proxy.ForwardHTTPConnection._connection","name":"_connection","setter_type":null,"type":"httpcore._sync.connection.HTTPConnection"}},"_proxy_headers":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http_proxy.ForwardHTTPConnection._proxy_headers","name":"_proxy_headers","setter_type":null,"type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.bytes","builtins.bytes"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"builtins.list"}}},"_proxy_origin":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http_proxy.ForwardHTTPConnection._proxy_origin","name":"_proxy_origin","setter_type":null,"type":"httpcore._models.Origin"}},"_remote_origin":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http_proxy.ForwardHTTPConnection._remote_origin","name":"_remote_origin","setter_type":null,"type":"httpcore._models.Origin"}},"can_handle_request":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","origin"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http_proxy.ForwardHTTPConnection.can_handle_request","name":"can_handle_request","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","origin"],"arg_types":["httpcore._sync.http_proxy.ForwardHTTPConnection","httpcore._models.Origin"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"can_handle_request of ForwardHTTPConnection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"close":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http_proxy.ForwardHTTPConnection.close","name":"close","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.http_proxy.ForwardHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"close of ForwardHTTPConnection","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"handle_request":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http_proxy.ForwardHTTPConnection.handle_request","name":"handle_request","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["httpcore._sync.http_proxy.ForwardHTTPConnection","httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"handle_request of ForwardHTTPConnection","ret_type":"httpcore._models.Response","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"has_expired":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http_proxy.ForwardHTTPConnection.has_expired","name":"has_expired","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.http_proxy.ForwardHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"has_expired of ForwardHTTPConnection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"info":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http_proxy.ForwardHTTPConnection.info","name":"info","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.http_proxy.ForwardHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"info of ForwardHTTPConnection","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_available":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http_proxy.ForwardHTTPConnection.is_available","name":"is_available","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.http_proxy.ForwardHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_available of ForwardHTTPConnection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_closed":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http_proxy.ForwardHTTPConnection.is_closed","name":"is_closed","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.http_proxy.ForwardHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_closed of ForwardHTTPConnection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_idle":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http_proxy.ForwardHTTPConnection.is_idle","name":"is_idle","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.http_proxy.ForwardHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_idle of ForwardHTTPConnection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._sync.http_proxy.ForwardHTTPConnection.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._sync.http_proxy.ForwardHTTPConnection","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"HTTP11Connection":{".class":"SymbolTableNode","cross_ref":"httpcore._sync.http11.HTTP11Connection","kind":"Gdef"},"HTTPConnection":{".class":"SymbolTableNode","cross_ref":"httpcore._sync.connection.HTTPConnection","kind":"Gdef"},"HTTPProxy":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["httpcore._sync.connection_pool.ConnectionPool"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._sync.http_proxy.HTTPProxy","name":"HTTPProxy","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._sync.http_proxy.HTTPProxy","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._sync.http_proxy","mro":["httpcore._sync.http_proxy.HTTPProxy","httpcore._sync.connection_pool.ConnectionPool","httpcore._sync.interfaces.RequestInterface","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1],"arg_names":["self","proxy_url","proxy_auth","proxy_headers","ssl_context","proxy_ssl_context","max_connections","max_keepalive_connections","keepalive_expiry","http1","http2","retries","local_address","uds","network_backend","socket_options"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http_proxy.HTTPProxy.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1],"arg_names":["self","proxy_url","proxy_auth","proxy_headers","ssl_context","proxy_ssl_context","max_connections","max_keepalive_connections","keepalive_expiry","http1","http2","retries","local_address","uds","network_backend","socket_options"],"arg_types":["httpcore._sync.http_proxy.HTTPProxy",{".class":"UnionType","items":["httpcore._models.URL","builtins.bytes","builtins.str"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.bytes","builtins.str"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bytes","builtins.str"],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._sync.http_proxy.HeadersAsMapping"},{".class":"TypeAliasType","args":[],"type_ref":"httpcore._sync.http_proxy.HeadersAsSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool","builtins.int",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["httpcore._backends.base.NetworkBackend",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._backends.base.SOCKET_OPTION"}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of HTTPProxy","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_proxy_headers":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http_proxy.HTTPProxy._proxy_headers","name":"_proxy_headers","setter_type":null,"type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.bytes","builtins.bytes"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"builtins.list"}}},"_proxy_ssl_context":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http_proxy.HTTPProxy._proxy_ssl_context","name":"_proxy_ssl_context","setter_type":null,"type":{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_proxy_url":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http_proxy.HTTPProxy._proxy_url","name":"_proxy_url","setter_type":null,"type":"httpcore._models.URL"}},"create_connection":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","origin"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http_proxy.HTTPProxy.create_connection","name":"create_connection","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","origin"],"arg_types":["httpcore._sync.http_proxy.HTTPProxy","httpcore._models.Origin"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"create_connection of HTTPProxy","ret_type":"httpcore._sync.interfaces.ConnectionInterface","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._sync.http_proxy.HTTPProxy.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._sync.http_proxy.HTTPProxy","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"HeadersAsMapping":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"httpcore._sync.http_proxy.HeadersAsMapping","line":29,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._sync.http_proxy.ByteOrStr"},{".class":"TypeAliasType","args":[],"type_ref":"httpcore._sync.http_proxy.ByteOrStr"}],"extra_attrs":null,"type_ref":"typing.Mapping"}}},"HeadersAsSequence":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"httpcore._sync.http_proxy.HeadersAsSequence","line":28,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._sync.http_proxy.ByteOrStr"},{".class":"TypeAliasType","args":[],"type_ref":"httpcore._sync.http_proxy.ByteOrStr"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"typing.Sequence"}}},"Lock":{".class":"SymbolTableNode","cross_ref":"httpcore._synchronization.Lock","kind":"Gdef"},"NetworkBackend":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.NetworkBackend","kind":"Gdef"},"Origin":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Origin","kind":"Gdef"},"ProxyError":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.ProxyError","kind":"Gdef"},"Request":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Request","kind":"Gdef"},"Response":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Response","kind":"Gdef"},"SOCKET_OPTION":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.SOCKET_OPTION","kind":"Gdef"},"Trace":{".class":"SymbolTableNode","cross_ref":"httpcore._trace.Trace","kind":"Gdef"},"TunnelHTTPConnection":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["httpcore._sync.interfaces.ConnectionInterface"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._sync.http_proxy.TunnelHTTPConnection","name":"TunnelHTTPConnection","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._sync.http_proxy.TunnelHTTPConnection","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._sync.http_proxy","mro":["httpcore._sync.http_proxy.TunnelHTTPConnection","httpcore._sync.interfaces.ConnectionInterface","httpcore._sync.interfaces.RequestInterface","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1,1,1,1,1,1],"arg_names":["self","proxy_origin","remote_origin","ssl_context","proxy_ssl_context","proxy_headers","keepalive_expiry","http1","http2","network_backend","socket_options"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http_proxy.TunnelHTTPConnection.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1,1,1,1,1],"arg_names":["self","proxy_origin","remote_origin","ssl_context","proxy_ssl_context","proxy_headers","keepalive_expiry","http1","http2","network_backend","socket_options"],"arg_types":["httpcore._sync.http_proxy.TunnelHTTPConnection","httpcore._models.Origin","httpcore._models.Origin",{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.bytes","builtins.bytes"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool",{".class":"UnionType","items":["httpcore._backends.base.NetworkBackend",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._backends.base.SOCKET_OPTION"}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of TunnelHTTPConnection","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http_proxy.TunnelHTTPConnection.__repr__","name":"__repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["httpcore._sync.http_proxy.TunnelHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr__ of TunnelHTTPConnection","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_connect_lock":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http_proxy.TunnelHTTPConnection._connect_lock","name":"_connect_lock","setter_type":null,"type":"httpcore._synchronization.Lock"}},"_connected":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http_proxy.TunnelHTTPConnection._connected","name":"_connected","setter_type":null,"type":"builtins.bool"}},"_connection":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._sync.http_proxy.TunnelHTTPConnection._connection","name":"_connection","setter_type":null,"type":"httpcore._sync.interfaces.ConnectionInterface"}},"_http1":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http_proxy.TunnelHTTPConnection._http1","name":"_http1","setter_type":null,"type":"builtins.bool"}},"_http2":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http_proxy.TunnelHTTPConnection._http2","name":"_http2","setter_type":null,"type":"builtins.bool"}},"_keepalive_expiry":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http_proxy.TunnelHTTPConnection._keepalive_expiry","name":"_keepalive_expiry","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_proxy_headers":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http_proxy.TunnelHTTPConnection._proxy_headers","name":"_proxy_headers","setter_type":null,"type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.bytes","builtins.bytes"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"builtins.list"}}},"_proxy_origin":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http_proxy.TunnelHTTPConnection._proxy_origin","name":"_proxy_origin","setter_type":null,"type":"httpcore._models.Origin"}},"_proxy_ssl_context":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http_proxy.TunnelHTTPConnection._proxy_ssl_context","name":"_proxy_ssl_context","setter_type":null,"type":{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_remote_origin":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http_proxy.TunnelHTTPConnection._remote_origin","name":"_remote_origin","setter_type":null,"type":"httpcore._models.Origin"}},"_ssl_context":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.http_proxy.TunnelHTTPConnection._ssl_context","name":"_ssl_context","setter_type":null,"type":{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"can_handle_request":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","origin"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http_proxy.TunnelHTTPConnection.can_handle_request","name":"can_handle_request","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","origin"],"arg_types":["httpcore._sync.http_proxy.TunnelHTTPConnection","httpcore._models.Origin"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"can_handle_request of TunnelHTTPConnection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"close":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http_proxy.TunnelHTTPConnection.close","name":"close","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.http_proxy.TunnelHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"close of TunnelHTTPConnection","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"handle_request":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http_proxy.TunnelHTTPConnection.handle_request","name":"handle_request","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["httpcore._sync.http_proxy.TunnelHTTPConnection","httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"handle_request of TunnelHTTPConnection","ret_type":"httpcore._models.Response","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"has_expired":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http_proxy.TunnelHTTPConnection.has_expired","name":"has_expired","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.http_proxy.TunnelHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"has_expired of TunnelHTTPConnection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"info":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http_proxy.TunnelHTTPConnection.info","name":"info","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.http_proxy.TunnelHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"info of TunnelHTTPConnection","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_available":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http_proxy.TunnelHTTPConnection.is_available","name":"is_available","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.http_proxy.TunnelHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_available of TunnelHTTPConnection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_closed":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http_proxy.TunnelHTTPConnection.is_closed","name":"is_closed","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.http_proxy.TunnelHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_closed of TunnelHTTPConnection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_idle":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.http_proxy.TunnelHTTPConnection.is_idle","name":"is_idle","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.http_proxy.TunnelHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_idle of TunnelHTTPConnection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._sync.http_proxy.TunnelHTTPConnection.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._sync.http_proxy.TunnelHTTPConnection","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"URL":{".class":"SymbolTableNode","cross_ref":"httpcore._models.URL","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.http_proxy.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.http_proxy.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.http_proxy.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.http_proxy.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.http_proxy.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.http_proxy.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"base64":{".class":"SymbolTableNode","cross_ref":"base64","kind":"Gdef"},"default_ssl_context":{".class":"SymbolTableNode","cross_ref":"httpcore._ssl.default_ssl_context","kind":"Gdef"},"enforce_bytes":{".class":"SymbolTableNode","cross_ref":"httpcore._models.enforce_bytes","kind":"Gdef"},"enforce_headers":{".class":"SymbolTableNode","cross_ref":"httpcore._models.enforce_headers","kind":"Gdef"},"enforce_url":{".class":"SymbolTableNode","cross_ref":"httpcore._models.enforce_url","kind":"Gdef"},"logger":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._sync.http_proxy.logger","name":"logger","setter_type":null,"type":"logging.Logger"}},"logging":{".class":"SymbolTableNode","cross_ref":"logging","kind":"Gdef"},"merge_headers":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1,1],"arg_names":["default_headers","override_headers"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"httpcore._sync.http_proxy.merge_headers","name":"merge_headers","original_first_arg":"default_headers","type":{".class":"CallableType","arg_kinds":[1,1],"arg_names":["default_headers","override_headers"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.bytes","builtins.bytes"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.bytes","builtins.bytes"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"merge_headers","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.bytes","builtins.bytes"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"ssl":{".class":"SymbolTableNode","cross_ref":"ssl","kind":"Gdef"},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_sync/http_proxy.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/http_proxy.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/http_proxy.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..8aa89bf4a516536f52d2d18dba99d8d9eb80efe7 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/http_proxy.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[8,22,23,24,25,328,9,10,19,20,21,1,3,4,5,6,1,1,1,1,1,1],"dep_prios":[5,5,5,5,5,20,5,5,5,5,5,5,10,10,10,10,5,30,30,30,30,30],"dependencies":["httpcore._backends.base","httpcore._sync.connection","httpcore._sync.connection_pool","httpcore._sync.http11","httpcore._sync.interfaces","httpcore._sync.http2","httpcore._exceptions","httpcore._models","httpcore._ssl","httpcore._synchronization","httpcore._trace","__future__","base64","logging","ssl","typing","builtins","_frozen_importlib","_ssl","abc","httpcore._backends","typing_extensions"],"hash":"7fdff2222f3e9b44e6a3554a282d2db744a5657a","id":"httpcore._sync.http_proxy","ignore_all":true,"interface_hash":"5ea061278195f85f634f414acd1da37d7caf53fe","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_sync/http_proxy.py","plugin_data":null,"size":14463,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/interfaces.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/interfaces.data.json new file mode 100644 index 0000000000000000000000000000000000000000..dd0fa8324b1b6a1c9e2255507dbc351acf003f07 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/interfaces.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"httpcore._sync.interfaces","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","ConnectionInterface":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["httpcore._sync.interfaces.RequestInterface"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._sync.interfaces.ConnectionInterface","name":"ConnectionInterface","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._sync.interfaces.ConnectionInterface","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._sync.interfaces","mro":["httpcore._sync.interfaces.ConnectionInterface","httpcore._sync.interfaces.RequestInterface","builtins.object"],"names":{".class":"SymbolTable","can_handle_request":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","origin"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.interfaces.ConnectionInterface.can_handle_request","name":"can_handle_request","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","origin"],"arg_types":["httpcore._sync.interfaces.ConnectionInterface","httpcore._models.Origin"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"can_handle_request of ConnectionInterface","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"close":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.interfaces.ConnectionInterface.close","name":"close","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.interfaces.ConnectionInterface"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"close of ConnectionInterface","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"has_expired":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.interfaces.ConnectionInterface.has_expired","name":"has_expired","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.interfaces.ConnectionInterface"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"has_expired of ConnectionInterface","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"info":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.interfaces.ConnectionInterface.info","name":"info","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.interfaces.ConnectionInterface"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"info of ConnectionInterface","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_available":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.interfaces.ConnectionInterface.is_available","name":"is_available","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.interfaces.ConnectionInterface"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_available of ConnectionInterface","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_closed":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.interfaces.ConnectionInterface.is_closed","name":"is_closed","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.interfaces.ConnectionInterface"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_closed of ConnectionInterface","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_idle":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.interfaces.ConnectionInterface.is_idle","name":"is_idle","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.interfaces.ConnectionInterface"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_idle of ConnectionInterface","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._sync.interfaces.ConnectionInterface.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._sync.interfaces.ConnectionInterface","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Extensions":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Extensions","kind":"Gdef"},"HeaderTypes":{".class":"SymbolTableNode","cross_ref":"httpcore._models.HeaderTypes","kind":"Gdef"},"Origin":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Origin","kind":"Gdef"},"Request":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Request","kind":"Gdef"},"RequestInterface":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._sync.interfaces.RequestInterface","name":"RequestInterface","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._sync.interfaces.RequestInterface","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._sync.interfaces","mro":["httpcore._sync.interfaces.RequestInterface","builtins.object"],"names":{".class":"SymbolTable","handle_request":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.interfaces.RequestInterface.handle_request","name":"handle_request","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["httpcore._sync.interfaces.RequestInterface","httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"handle_request of RequestInterface","ret_type":"httpcore._models.Response","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"request":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5,5,5],"arg_names":["self","method","url","headers","content","extensions"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.interfaces.RequestInterface.request","name":"request","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,5,5,5],"arg_names":["self","method","url","headers","content","extensions"],"arg_types":["httpcore._sync.interfaces.RequestInterface",{".class":"UnionType","items":["builtins.bytes","builtins.str"],"uses_pep604_syntax":true},{".class":"UnionType","items":["httpcore._models.URL","builtins.bytes","builtins.str"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._models.HeaderTypes"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterator"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._models.Extensions"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"request of RequestInterface","ret_type":"httpcore._models.Response","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"stream":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5,5,5],"arg_names":["self","method","url","headers","content","extensions"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated","is_trivial_self"],"fullname":"httpcore._sync.interfaces.RequestInterface.stream","name":"stream","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,5,5,5],"arg_names":["self","method","url","headers","content","extensions"],"arg_types":["httpcore._sync.interfaces.RequestInterface",{".class":"UnionType","items":["builtins.bytes","builtins.str"],"uses_pep604_syntax":true},{".class":"UnionType","items":["httpcore._models.URL","builtins.bytes","builtins.str"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._models.HeaderTypes"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterator"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._models.Extensions"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"stream of RequestInterface","ret_type":{".class":"Instance","args":["httpcore._models.Response"],"extra_attrs":null,"type_ref":"typing.Iterator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred"],"fullname":"httpcore._sync.interfaces.RequestInterface.stream","name":"stream","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,5,5,5],"arg_names":["self","method","url","headers","content","extensions"],"arg_types":["httpcore._sync.interfaces.RequestInterface",{".class":"UnionType","items":["builtins.bytes","builtins.str"],"uses_pep604_syntax":true},{".class":"UnionType","items":["httpcore._models.URL","builtins.bytes","builtins.str"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._models.HeaderTypes"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterator"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"httpcore._models.Extensions"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"stream of RequestInterface","ret_type":{".class":"Instance","args":["httpcore._models.Response",{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._sync.interfaces.RequestInterface.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._sync.interfaces.RequestInterface","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Response":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Response","kind":"Gdef"},"URL":{".class":"SymbolTableNode","cross_ref":"httpcore._models.URL","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.interfaces.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.interfaces.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.interfaces.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.interfaces.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.interfaces.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.interfaces.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"contextlib":{".class":"SymbolTableNode","cross_ref":"contextlib","kind":"Gdef"},"enforce_bytes":{".class":"SymbolTableNode","cross_ref":"httpcore._models.enforce_bytes","kind":"Gdef"},"enforce_headers":{".class":"SymbolTableNode","cross_ref":"httpcore._models.enforce_headers","kind":"Gdef"},"enforce_url":{".class":"SymbolTableNode","cross_ref":"httpcore._models.enforce_url","kind":"Gdef"},"include_request_headers":{".class":"SymbolTableNode","cross_ref":"httpcore._models.include_request_headers","kind":"Gdef"},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_sync/interfaces.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/interfaces.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/interfaces.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..25f1439c54717bc2536141f59a747088f35cd25b --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/interfaces.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[6,1,3,4,1,1,1],"dep_prios":[5,5,10,10,5,30,30],"dependencies":["httpcore._models","__future__","contextlib","typing","builtins","_frozen_importlib","abc"],"hash":"ed8973a7c70133bac25e2c2a8ae995b436cff854","id":"httpcore._sync.interfaces","ignore_all":true,"interface_hash":"a5f1d9f4bacab60a449f5300837e48cccad25fa2","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_sync/interfaces.py","plugin_data":null,"size":4344,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/socks_proxy.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/socks_proxy.data.json new file mode 100644 index 0000000000000000000000000000000000000000..6bd0b03f4c70885eb65ff68a1b9812a1ba028d98 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/socks_proxy.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"httpcore._sync.socks_proxy","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","AUTH_METHODS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._sync.socks_proxy.AUTH_METHODS","name":"AUTH_METHODS","setter_type":null,"type":{".class":"Instance","args":["builtins.bytes","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"ConnectionInterface":{".class":"SymbolTableNode","cross_ref":"httpcore._sync.interfaces.ConnectionInterface","kind":"Gdef"},"ConnectionNotAvailable":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.ConnectionNotAvailable","kind":"Gdef"},"ConnectionPool":{".class":"SymbolTableNode","cross_ref":"httpcore._sync.connection_pool.ConnectionPool","kind":"Gdef"},"HTTP11Connection":{".class":"SymbolTableNode","cross_ref":"httpcore._sync.http11.HTTP11Connection","kind":"Gdef"},"Lock":{".class":"SymbolTableNode","cross_ref":"httpcore._synchronization.Lock","kind":"Gdef"},"NetworkBackend":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.NetworkBackend","kind":"Gdef"},"NetworkStream":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.base.NetworkStream","kind":"Gdef"},"Origin":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Origin","kind":"Gdef"},"ProxyError":{".class":"SymbolTableNode","cross_ref":"httpcore._exceptions.ProxyError","kind":"Gdef"},"REPLY_CODES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._sync.socks_proxy.REPLY_CODES","name":"REPLY_CODES","setter_type":null,"type":{".class":"Instance","args":["builtins.bytes","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"Request":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Request","kind":"Gdef"},"Response":{".class":"SymbolTableNode","cross_ref":"httpcore._models.Response","kind":"Gdef"},"SOCKSProxy":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["httpcore._sync.connection_pool.ConnectionPool"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._sync.socks_proxy.SOCKSProxy","name":"SOCKSProxy","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._sync.socks_proxy.SOCKSProxy","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._sync.socks_proxy","mro":["httpcore._sync.socks_proxy.SOCKSProxy","httpcore._sync.connection_pool.ConnectionPool","httpcore._sync.interfaces.RequestInterface","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,1,1,1,1],"arg_names":["self","proxy_url","proxy_auth","ssl_context","max_connections","max_keepalive_connections","keepalive_expiry","http1","http2","retries","network_backend"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.socks_proxy.SOCKSProxy.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1,1,1,1],"arg_names":["self","proxy_url","proxy_auth","ssl_context","max_connections","max_keepalive_connections","keepalive_expiry","http1","http2","retries","network_backend"],"arg_types":["httpcore._sync.socks_proxy.SOCKSProxy",{".class":"UnionType","items":["httpcore._models.URL","builtins.bytes","builtins.str"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.bytes","builtins.str"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bytes","builtins.str"],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool","builtins.int",{".class":"UnionType","items":["httpcore._backends.base.NetworkBackend",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of SOCKSProxy","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_proxy_auth":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._sync.socks_proxy.SOCKSProxy._proxy_auth","name":"_proxy_auth","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TupleType","implicit":false,"items":["builtins.bytes","builtins.bytes"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_proxy_url":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.socks_proxy.SOCKSProxy._proxy_url","name":"_proxy_url","setter_type":null,"type":"httpcore._models.URL"}},"create_connection":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","origin"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.socks_proxy.SOCKSProxy.create_connection","name":"create_connection","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","origin"],"arg_types":["httpcore._sync.socks_proxy.SOCKSProxy","httpcore._models.Origin"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"create_connection of SOCKSProxy","ret_type":"httpcore._sync.interfaces.ConnectionInterface","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._sync.socks_proxy.SOCKSProxy.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._sync.socks_proxy.SOCKSProxy","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Socks5Connection":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["httpcore._sync.interfaces.ConnectionInterface"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"httpcore._sync.socks_proxy.Socks5Connection","name":"Socks5Connection","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"httpcore._sync.socks_proxy.Socks5Connection","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"httpcore._sync.socks_proxy","mro":["httpcore._sync.socks_proxy.Socks5Connection","httpcore._sync.interfaces.ConnectionInterface","httpcore._sync.interfaces.RequestInterface","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1,1,1,1],"arg_names":["self","proxy_origin","remote_origin","proxy_auth","ssl_context","keepalive_expiry","http1","http2","network_backend"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.socks_proxy.Socks5Connection.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1,1,1],"arg_names":["self","proxy_origin","remote_origin","proxy_auth","ssl_context","keepalive_expiry","http1","http2","network_backend"],"arg_types":["httpcore._sync.socks_proxy.Socks5Connection","httpcore._models.Origin","httpcore._models.Origin",{".class":"UnionType","items":[{".class":"TupleType","implicit":false,"items":["builtins.bytes","builtins.bytes"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool",{".class":"UnionType","items":["httpcore._backends.base.NetworkBackend",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of Socks5Connection","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.socks_proxy.Socks5Connection.__repr__","name":"__repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["httpcore._sync.socks_proxy.Socks5Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr__ of Socks5Connection","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_connect_failed":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.socks_proxy.Socks5Connection._connect_failed","name":"_connect_failed","setter_type":null,"type":"builtins.bool"}},"_connect_lock":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.socks_proxy.Socks5Connection._connect_lock","name":"_connect_lock","setter_type":null,"type":"httpcore._synchronization.Lock"}},"_connection":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._sync.socks_proxy.Socks5Connection._connection","name":"_connection","setter_type":null,"type":{".class":"UnionType","items":["httpcore._sync.interfaces.ConnectionInterface",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_http1":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.socks_proxy.Socks5Connection._http1","name":"_http1","setter_type":null,"type":"builtins.bool"}},"_http2":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.socks_proxy.Socks5Connection._http2","name":"_http2","setter_type":null,"type":"builtins.bool"}},"_keepalive_expiry":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.socks_proxy.Socks5Connection._keepalive_expiry","name":"_keepalive_expiry","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_network_backend":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"httpcore._sync.socks_proxy.Socks5Connection._network_backend","name":"_network_backend","setter_type":null,"type":"httpcore._backends.base.NetworkBackend"}},"_proxy_auth":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.socks_proxy.Socks5Connection._proxy_auth","name":"_proxy_auth","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TupleType","implicit":false,"items":["builtins.bytes","builtins.bytes"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_proxy_origin":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.socks_proxy.Socks5Connection._proxy_origin","name":"_proxy_origin","setter_type":null,"type":"httpcore._models.Origin"}},"_remote_origin":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.socks_proxy.Socks5Connection._remote_origin","name":"_remote_origin","setter_type":null,"type":"httpcore._models.Origin"}},"_ssl_context":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"httpcore._sync.socks_proxy.Socks5Connection._ssl_context","name":"_ssl_context","setter_type":null,"type":{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"can_handle_request":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","origin"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.socks_proxy.Socks5Connection.can_handle_request","name":"can_handle_request","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","origin"],"arg_types":["httpcore._sync.socks_proxy.Socks5Connection","httpcore._models.Origin"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"can_handle_request of Socks5Connection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"close":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.socks_proxy.Socks5Connection.close","name":"close","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.socks_proxy.Socks5Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"close of Socks5Connection","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"handle_request":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.socks_proxy.Socks5Connection.handle_request","name":"handle_request","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","request"],"arg_types":["httpcore._sync.socks_proxy.Socks5Connection","httpcore._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"handle_request of Socks5Connection","ret_type":"httpcore._models.Response","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"has_expired":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.socks_proxy.Socks5Connection.has_expired","name":"has_expired","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.socks_proxy.Socks5Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"has_expired of Socks5Connection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"info":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.socks_proxy.Socks5Connection.info","name":"info","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.socks_proxy.Socks5Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"info of Socks5Connection","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_available":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.socks_proxy.Socks5Connection.is_available","name":"is_available","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.socks_proxy.Socks5Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_available of Socks5Connection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_closed":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.socks_proxy.Socks5Connection.is_closed","name":"is_closed","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.socks_proxy.Socks5Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_closed of Socks5Connection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_idle":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"httpcore._sync.socks_proxy.Socks5Connection.is_idle","name":"is_idle","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["httpcore._sync.socks_proxy.Socks5Connection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_idle of Socks5Connection","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"httpcore._sync.socks_proxy.Socks5Connection.Self","id":0,"name":"Self","namespace":"","upper_bound":"httpcore._sync.socks_proxy.Socks5Connection","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"SyncBackend":{".class":"SymbolTableNode","cross_ref":"httpcore._backends.sync.SyncBackend","kind":"Gdef"},"Trace":{".class":"SymbolTableNode","cross_ref":"httpcore._trace.Trace","kind":"Gdef"},"URL":{".class":"SymbolTableNode","cross_ref":"httpcore._models.URL","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.socks_proxy.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.socks_proxy.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.socks_proxy.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.socks_proxy.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.socks_proxy.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"httpcore._sync.socks_proxy.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_init_socks5_connection":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,3,5],"arg_names":["stream","host","port","auth"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"httpcore._sync.socks_proxy._init_socks5_connection","name":"_init_socks5_connection","original_first_arg":"stream","type":{".class":"CallableType","arg_kinds":[0,3,3,5],"arg_names":["stream","host","port","auth"],"arg_types":["httpcore._backends.base.NetworkStream","builtins.bytes","builtins.int",{".class":"UnionType","items":[{".class":"TupleType","implicit":false,"items":["builtins.bytes","builtins.bytes"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_init_socks5_connection","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"default_ssl_context":{".class":"SymbolTableNode","cross_ref":"httpcore._ssl.default_ssl_context","kind":"Gdef"},"enforce_bytes":{".class":"SymbolTableNode","cross_ref":"httpcore._models.enforce_bytes","kind":"Gdef"},"enforce_url":{".class":"SymbolTableNode","cross_ref":"httpcore._models.enforce_url","kind":"Gdef"},"logger":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"httpcore._sync.socks_proxy.logger","name":"logger","setter_type":null,"type":"logging.Logger"}},"logging":{".class":"SymbolTableNode","cross_ref":"logging","kind":"Gdef"},"socksio":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"httpcore._sync.socks_proxy.socksio","name":"socksio","setter_type":null,"type":{".class":"AnyType","missing_import_name":"httpcore._sync.socks_proxy.socksio","source_any":null,"type_of_any":3}}},"ssl":{".class":"SymbolTableNode","cross_ref":"ssl","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_sync/socks_proxy.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/socks_proxy.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/socks_proxy.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..22ef8f6a7dfb07e40ab53e9c09c0eadc5c2086f4 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpcore/_sync/socks_proxy.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[8,9,15,16,17,280,10,11,12,13,14,1,3,4,1,1,1,1,1,1,6],"dep_prios":[5,5,5,5,5,20,5,5,5,5,5,5,10,10,5,30,30,30,30,30,10],"dependencies":["httpcore._backends.sync","httpcore._backends.base","httpcore._sync.connection_pool","httpcore._sync.http11","httpcore._sync.interfaces","httpcore._sync.http2","httpcore._exceptions","httpcore._models","httpcore._ssl","httpcore._synchronization","httpcore._trace","__future__","logging","ssl","builtins","_frozen_importlib","_ssl","abc","httpcore._backends","typing"],"hash":"1c317f91e1bf0ee5e6456142583b6d427bb2536b","id":"httpcore._sync.socks_proxy","ignore_all":true,"interface_hash":"bfaecfc92be16197f3a0d4fdabdadd8039548ba4","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpcore/_sync/socks_proxy.py","plugin_data":null,"size":13614,"suppressed":["socksio"],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpx/_transports/base.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpx/_transports/base.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..f087d4757654a267dc366886d0fd2394e319a0ee --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpx/_transports/base.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[6,1,3,4,1,1,1],"dep_prios":[5,5,10,5,5,30,30],"dependencies":["httpx._models","__future__","typing","types","builtins","_frozen_importlib","abc"],"hash":"5bef1d723951a51c09bcb4ad81445fcae0d5715b","id":"httpx._transports.base","ignore_all":true,"interface_hash":"5fd38ba7e40756a4a16dee5250172186325788b1","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpx/_transports/base.py","plugin_data":null,"size":2523,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpx/_transports/default.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpx/_transports/default.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..9f792692b7dc6dd955e1759cb1fc0d9f03425aba --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpx/_transports/default.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106718,"dep_lines":[58,38,39,55,56,57,27,29,30,31,34,36,150,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,189],"dep_prios":[5,5,5,5,5,5,5,10,10,5,25,25,20,5,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,20],"dependencies":["httpx._transports.base","httpx._config","httpx._exceptions","httpx._models","httpx._types","httpx._urls","__future__","contextlib","typing","types","ssl","httpx","httpcore","builtins","_frozen_importlib","_ssl","abc","httpcore._async","httpcore._async.connection_pool","httpcore._async.http_proxy","httpcore._async.interfaces","httpcore._async.socks_proxy","httpcore._backends","httpcore._backends.base","httpcore._models","httpcore._sync","httpcore._sync.connection_pool","httpcore._sync.http_proxy","httpcore._sync.interfaces","httpcore._sync.socks_proxy","typing_extensions"],"hash":"79fd270cb3f27adcc29817efed9b57bd125b3b1d","id":"httpx._transports.default","ignore_all":true,"interface_hash":"2d804dfdb6ce0667049e2e4fa9b2d45ea50888e4","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpx/_transports/default.py","plugin_data":null,"size":13983,"suppressed":["socksio"],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpx/_transports/wsgi.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpx/_transports/wsgi.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..7feb9d3df9cfdf8b5945013cef725a5d55ed1e40 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/httpx/_transports/wsgi.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[10,8,9,14,1,3,4,5,6,13,1,1,1],"dep_prios":[5,5,5,25,5,10,10,10,10,25,5,30,30],"dependencies":["httpx._transports.base","httpx._models","httpx._types","_typeshed.wsgi","__future__","io","itertools","sys","typing","_typeshed","builtins","_frozen_importlib","abc"],"hash":"fe048ef6ab57db5e03af35f83bbd9b3b509957ae","id":"httpx._transports.wsgi","ignore_all":true,"interface_hash":"79e9e66949483c467298f2a7d2f3aab63bab9410","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/httpx/_transports/wsgi.py","plugin_data":null,"size":4825,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/cli/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/cli/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..612c9c82b7f85aed6c00f62a060a0b4f10d8a567 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/cli/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.cli","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.cli.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.cli.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.cli.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.cli.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.cli.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.cli.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.cli.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/cli/__init__.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/cli/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/cli/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..95823aeb18e46c92144bf9379bf74628cf15a8c7 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/cli/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106714,"dep_lines":[1,1,1,1],"dep_prios":[5,30,30,30],"dependencies":["builtins","_frozen_importlib","abc","typing"],"hash":"786310ee56c714e51b94a0f39462ceca40868f27","id":"huggingface_hub.cli","ignore_all":true,"interface_hash":"d3ecc1aedccb23b648b7fec543246d545da8a76c","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/cli/__init__.py","plugin_data":null,"size":606,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/cli/_cli_utils.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/cli/_cli_utils.data.json new file mode 100644 index 0000000000000000000000000000000000000000..777d6f069a8a05e22bf6b4d00d45b12350911185 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/cli/_cli_utils.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.cli._cli_utils","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","ANSI":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._terminal.ANSI","kind":"Gdef"},"AlphabeticalMixedGroup":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typer.core.TyperGroup"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.cli._cli_utils.AlphabeticalMixedGroup","name":"AlphabeticalMixedGroup","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.cli._cli_utils.AlphabeticalMixedGroup","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.cli._cli_utils","mro":["huggingface_hub.cli._cli_utils.AlphabeticalMixedGroup","typer.core.TyperGroup","click.core.Group","click.core.Command","builtins.object"],"names":{".class":"SymbolTable","list_commands":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","ctx"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.cli._cli_utils.AlphabeticalMixedGroup.list_commands","name":"list_commands","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","ctx"],"arg_types":["huggingface_hub.cli._cli_utils.AlphabeticalMixedGroup","click.core.Context"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"list_commands of AlphabeticalMixedGroup","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.cli._cli_utils.AlphabeticalMixedGroup.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.cli._cli_utils.AlphabeticalMixedGroup","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Annotated":{".class":"SymbolTableNode","cross_ref":"typing.Annotated","kind":"Gdef"},"Enum":{".class":"SymbolTableNode","cross_ref":"enum.Enum","kind":"Gdef"},"HfApi":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.hf_api.HfApi","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"Path":{".class":"SymbolTableNode","cross_ref":"pathlib.Path","kind":"Gdef"},"PrivateOpt":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.cli._cli_utils.PrivateOpt","line":98,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":"builtins.bool"}},"RepoIdArg":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.cli._cli_utils.RepoIdArg","line":76,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":"builtins.str"}},"RepoType":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.str","enum.Enum"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.cli._cli_utils.RepoType","name":"RepoType","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_enum"],"fullname":"huggingface_hub.cli._cli_utils.RepoType","has_param_spec_type":false,"metaclass_type":"enum.EnumMeta","metadata":{},"module_name":"huggingface_hub.cli._cli_utils","mro":["huggingface_hub.cli._cli_utils.RepoType","builtins.str","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","enum.Enum","builtins.object"],"names":{".class":"SymbolTable","dataset":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.cli._cli_utils.RepoType.dataset","name":"dataset","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.str","value":"dataset"},"type_ref":"builtins.str"}}},"model":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.cli._cli_utils.RepoType.model","name":"model","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.str","value":"model"},"type_ref":"builtins.str"}}},"space":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.cli._cli_utils.RepoType.space","name":"space","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.str","value":"space"},"type_ref":"builtins.str"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.cli._cli_utils.RepoType.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.cli._cli_utils.RepoType","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"RepoTypeOpt":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.cli._cli_utils.RepoTypeOpt","line":84,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":"huggingface_hub.cli._cli_utils.RepoType"}},"RevisionOpt":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.cli._cli_utils.RevisionOpt","line":105,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"TokenOpt":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.cli._cli_utils.TokenOpt","line":91,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.cli._cli_utils.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.cli._cli_utils.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.cli._cli_utils.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.cli._cli_utils.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.cli._cli_utils.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.cli._cli_utils.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"__version__":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.__version__","kind":"Gdef"},"_check_cli_update":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.cli._cli_utils._check_cli_update","name":"_check_cli_update","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_check_cli_update","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"check_cli_update":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.cli._cli_utils.check_cli_update","name":"check_cli_update","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"check_cli_update","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"click":{".class":"SymbolTableNode","cross_ref":"click","kind":"Gdef"},"constants":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.constants","kind":"Gdef"},"get_hf_api":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1],"arg_names":["token"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.cli._cli_utils.get_hf_api","name":"get_hf_api","original_first_arg":"token","type":{".class":"CallableType","arg_kinds":[1],"arg_names":["token"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_hf_api","ret_type":"huggingface_hub.hf_api.HfApi","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_session":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._http.get_session","kind":"Gdef"},"hf_raise_for_status":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._http.hf_raise_for_status","kind":"Gdef"},"importlib":{".class":"SymbolTableNode","cross_ref":"importlib","kind":"Gdef"},"installation_method":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.installation_method","kind":"Gdef"},"logger":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.cli._cli_utils.logger","name":"logger","setter_type":null,"type":"logging.Logger"}},"logging":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils.logging","kind":"Gdef"},"os":{".class":"SymbolTableNode","cross_ref":"os","kind":"Gdef"},"time":{".class":"SymbolTableNode","cross_ref":"time","kind":"Gdef"},"typer":{".class":"SymbolTableNode","cross_ref":"typer","kind":"Gdef"},"typer_factory":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["help"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.cli._cli_utils.typer_factory","name":"typer_factory","original_first_arg":"help","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["help"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typer_factory","ret_type":"typer.main.Typer","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/cli/_cli_utils.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/cli/_cli_utils.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/cli/_cli_utils.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..02f4758b89a1f89e71abcb42ecd24e6ccd45052f --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/cli/_cli_utils.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[27,16,26,27,34,16,17,18,19,20,21,23,24,26,1,1,1,1,1,1,1,1],"dep_prios":[10,10,10,5,25,20,10,10,5,5,5,10,10,5,5,30,30,30,30,30,30,30],"dependencies":["huggingface_hub.utils.logging","importlib.metadata","huggingface_hub.constants","huggingface_hub.utils","huggingface_hub.hf_api","importlib","os","time","enum","pathlib","typing","click","typer","huggingface_hub","builtins","_frozen_importlib","abc","click.core","logging","typer.core","typer.main","typing_extensions"],"hash":"2a8a58a82fae1d8f8a196eeffe371db1a2a6e888","id":"huggingface_hub.cli._cli_utils","ignore_all":true,"interface_hash":"e3306178e4397a905b1a53ca5a14121117ea67e5","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/cli/_cli_utils.py","plugin_data":null,"size":5403,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..09a660c23d423d9ac7e9006b633f2f120971762c --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/__init__.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..454e3d9283aa67ecf5ee40c22344296d94cce4dc --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106714,"dep_lines":[1,1,1,1],"dep_prios":[5,30,30,30],"dependencies":["builtins","_frozen_importlib","abc","typing"],"hash":"da39a3ee5e6b4b0d3255bfef95601890afd80709","id":"huggingface_hub.inference","ignore_all":true,"interface_hash":"cb62f162162e3e3f705effac9fd265580964c0d6","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/__init__.py","plugin_data":null,"size":0,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_client.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_client.data.json new file mode 100644 index 0000000000000000000000000000000000000000..3d84742288d4ea9f41e9212f78b8487fa1066cdd --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_client.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._client","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"AudioClassificationOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.audio_classification.AudioClassificationOutputElement","kind":"Gdef"},"AudioClassificationOutputTransform":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.audio_classification.AudioClassificationOutputTransform","kind":"Gdef"},"AudioToAudioOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.audio_to_audio.AudioToAudioOutputElement","kind":"Gdef"},"AutomaticSpeechRecognitionOutput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionOutput","kind":"Gdef"},"BadRequestError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.BadRequestError","kind":"Gdef"},"ChatCompletionInputGrammarType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputGrammarType","kind":"Gdef"},"ChatCompletionInputMessage":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage","kind":"Gdef"},"ChatCompletionInputStreamOptions":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputStreamOptions","kind":"Gdef"},"ChatCompletionInputTool":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool","kind":"Gdef"},"ChatCompletionInputToolChoiceClass":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceClass","kind":"Gdef"},"ChatCompletionInputToolChoiceEnum":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceEnum","kind":"Gdef"},"ChatCompletionOutput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutput","kind":"Gdef"},"ChatCompletionStreamOutput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutput","kind":"Gdef"},"ContentT":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common.ContentT","kind":"Gdef"},"DocumentQuestionAnsweringOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringOutputElement","kind":"Gdef"},"ExitStack":{".class":"SymbolTableNode","cross_ref":"contextlib.ExitStack","kind":"Gdef"},"FillMaskOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.fill_mask.FillMaskOutputElement","kind":"Gdef"},"HfHubHTTPError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.HfHubHTTPError","kind":"Gdef"},"Image":{".class":"SymbolTableNode","cross_ref":"PIL.Image.Image","kind":"Gdef"},"ImageClassificationOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.image_classification.ImageClassificationOutputElement","kind":"Gdef"},"ImageClassificationOutputTransform":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.image_classification.ImageClassificationOutputTransform","kind":"Gdef"},"ImageSegmentationOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationOutputElement","kind":"Gdef"},"ImageSegmentationSubtask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationSubtask","kind":"Gdef"},"ImageToImageTargetSize":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.image_to_image.ImageToImageTargetSize","kind":"Gdef"},"ImageToTextOutput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextOutput","kind":"Gdef"},"ImageToVideoTargetSize":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.image_to_video.ImageToVideoTargetSize","kind":"Gdef"},"InferenceClient":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._client.InferenceClient","name":"InferenceClient","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._client.InferenceClient","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._client","mro":["huggingface_hub.inference._client.InferenceClient","builtins.object"],"names":{".class":"SymbolTable","__enter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._client.InferenceClient.__enter__","name":"__enter__","original_first_arg":"self","type":null}},"__exit__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":[null,null,null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._client.InferenceClient.__exit__","name":"__exit__","original_first_arg":"self","type":null}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,5,5,5,5,5,5,5,5],"arg_names":["self","model","provider","token","timeout","headers","cookies","bill_to","base_url","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated","is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,5,5,5,5,5,5,5,5],"arg_names":["self","model","provider","token","timeout","headers","cookies","bill_to","base_url","api_key"],"arg_types":["huggingface_hub.inference._client.InferenceClient",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._providers.PROVIDER_OR_POLICY_T"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of InferenceClient","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred"],"fullname":"huggingface_hub.inference._client.InferenceClient.__init__","name":"__init__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,5,5,5,5,5,5,5,5],"arg_names":["self","model","provider","token","timeout","headers","cookies","bill_to","base_url","api_key"],"arg_types":["huggingface_hub.inference._client.InferenceClient",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._providers.PROVIDER_OR_POLICY_T"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of InferenceClient","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._client.InferenceClient.__repr__","name":"__repr__","original_first_arg":"self","type":null}},"_inner_post":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._client.InferenceClient._inner_post","impl":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5],"arg_names":["self","request_parameters","stream"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient._inner_post","name":"_inner_post","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["self","request_parameters","stream"],"arg_types":["huggingface_hub.inference._client.InferenceClient","huggingface_hub.inference._common.RequestParameters","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_inner_post of InferenceClient","ret_type":{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5],"arg_names":["self","request_parameters","stream"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient._inner_post","name":"_inner_post","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["self","request_parameters","stream"],"arg_types":["huggingface_hub.inference._client.InferenceClient","huggingface_hub.inference._common.RequestParameters",{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_inner_post of InferenceClient","ret_type":"builtins.bytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._client.InferenceClient._inner_post","name":"_inner_post","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["self","request_parameters","stream"],"arg_types":["huggingface_hub.inference._client.InferenceClient","huggingface_hub.inference._common.RequestParameters",{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_inner_post of InferenceClient","ret_type":"builtins.bytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5],"arg_names":["self","request_parameters","stream"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient._inner_post","name":"_inner_post","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["self","request_parameters","stream"],"arg_types":["huggingface_hub.inference._client.InferenceClient","huggingface_hub.inference._common.RequestParameters",{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_inner_post of InferenceClient","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._client.InferenceClient._inner_post","name":"_inner_post","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["self","request_parameters","stream"],"arg_types":["huggingface_hub.inference._client.InferenceClient","huggingface_hub.inference._common.RequestParameters",{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_inner_post of InferenceClient","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5],"arg_names":["self","request_parameters","stream"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient._inner_post","name":"_inner_post","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["self","request_parameters","stream"],"arg_types":["huggingface_hub.inference._client.InferenceClient","huggingface_hub.inference._common.RequestParameters","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_inner_post of InferenceClient","ret_type":{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._client.InferenceClient._inner_post","name":"_inner_post","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["self","request_parameters","stream"],"arg_types":["huggingface_hub.inference._client.InferenceClient","huggingface_hub.inference._common.RequestParameters","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_inner_post of InferenceClient","ret_type":{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["self","request_parameters","stream"],"arg_types":["huggingface_hub.inference._client.InferenceClient","huggingface_hub.inference._common.RequestParameters",{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_inner_post of InferenceClient","ret_type":"builtins.bytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["self","request_parameters","stream"],"arg_types":["huggingface_hub.inference._client.InferenceClient","huggingface_hub.inference._common.RequestParameters",{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_inner_post of InferenceClient","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["self","request_parameters","stream"],"arg_types":["huggingface_hub.inference._client.InferenceClient","huggingface_hub.inference._common.RequestParameters","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_inner_post of InferenceClient","ret_type":{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"audio_classification":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5],"arg_names":["self","audio","model","top_k","function_to_apply"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.audio_classification","name":"audio_classification","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5],"arg_names":["self","audio","model","top_k","function_to_apply"],"arg_types":["huggingface_hub.inference._client.InferenceClient",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._common.ContentT"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.audio_classification.AudioClassificationOutputTransform"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"audio_classification of InferenceClient","ret_type":{".class":"Instance","args":["huggingface_hub.inference._generated.types.audio_classification.AudioClassificationOutputElement"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"audio_to_audio":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5],"arg_names":["self","audio","model"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.audio_to_audio","name":"audio_to_audio","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["self","audio","model"],"arg_types":["huggingface_hub.inference._client.InferenceClient",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._common.ContentT"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"audio_to_audio of InferenceClient","ret_type":{".class":"Instance","args":["huggingface_hub.inference._generated.types.audio_to_audio.AudioToAudioOutputElement"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"automatic_speech_recognition":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5],"arg_names":["self","audio","model","extra_body"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.automatic_speech_recognition","name":"automatic_speech_recognition","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5],"arg_names":["self","audio","model","extra_body"],"arg_types":["huggingface_hub.inference._client.InferenceClient",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._common.ContentT"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"automatic_speech_recognition of InferenceClient","ret_type":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionOutput","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"chat":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.chat","name":"chat","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.inference._client.InferenceClient"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chat of InferenceClient","ret_type":"huggingface_hub.inference._client.ProxyClientChat","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"huggingface_hub.inference._client.InferenceClient.chat","name":"chat","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.inference._client.InferenceClient"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chat of InferenceClient","ret_type":"huggingface_hub.inference._client.ProxyClientChat","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"chat_completion":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._client.InferenceClient.chat_completion","impl":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","messages","model","stream","frequency_penalty","logit_bias","logprobs","max_tokens","n","presence_penalty","response_format","seed","stop","stream_options","temperature","tool_choice","tool_prompt","tools","top_logprobs","top_p","extra_body"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.chat_completion","name":"chat_completion","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","messages","model","stream","frequency_penalty","logit_bias","logprobs","max_tokens","n","presence_penalty","response_format","seed","stop","stream_options","temperature","tool_choice","tool_prompt","tools","top_logprobs","top_p","extra_body"],"arg_types":["huggingface_hub.inference._client.InferenceClient",{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputGrammarType"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputStreamOptions",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceClass",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceEnum"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chat_completion of InferenceClient","ret_type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutput",{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutput"],"extra_attrs":null,"type_ref":"typing.Iterable"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","messages","model","stream","frequency_penalty","logit_bias","logprobs","max_tokens","n","presence_penalty","response_format","seed","stop","stream_options","temperature","tool_choice","tool_prompt","tools","top_logprobs","top_p","extra_body"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.chat_completion","name":"chat_completion","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","messages","model","stream","frequency_penalty","logit_bias","logprobs","max_tokens","n","presence_penalty","response_format","seed","stop","stream_options","temperature","tool_choice","tool_prompt","tools","top_logprobs","top_p","extra_body"],"arg_types":["huggingface_hub.inference._client.InferenceClient",{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputGrammarType"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputStreamOptions",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceClass",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceEnum"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chat_completion of InferenceClient","ret_type":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutput","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._client.InferenceClient.chat_completion","name":"chat_completion","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","messages","model","stream","frequency_penalty","logit_bias","logprobs","max_tokens","n","presence_penalty","response_format","seed","stop","stream_options","temperature","tool_choice","tool_prompt","tools","top_logprobs","top_p","extra_body"],"arg_types":["huggingface_hub.inference._client.InferenceClient",{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputGrammarType"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputStreamOptions",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceClass",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceEnum"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chat_completion of InferenceClient","ret_type":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutput","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","messages","model","stream","frequency_penalty","logit_bias","logprobs","max_tokens","n","presence_penalty","response_format","seed","stop","stream_options","temperature","tool_choice","tool_prompt","tools","top_logprobs","top_p","extra_body"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.chat_completion","name":"chat_completion","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","messages","model","stream","frequency_penalty","logit_bias","logprobs","max_tokens","n","presence_penalty","response_format","seed","stop","stream_options","temperature","tool_choice","tool_prompt","tools","top_logprobs","top_p","extra_body"],"arg_types":["huggingface_hub.inference._client.InferenceClient",{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputGrammarType"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputStreamOptions",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceClass",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceEnum"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chat_completion of InferenceClient","ret_type":{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutput"],"extra_attrs":null,"type_ref":"typing.Iterable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._client.InferenceClient.chat_completion","name":"chat_completion","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","messages","model","stream","frequency_penalty","logit_bias","logprobs","max_tokens","n","presence_penalty","response_format","seed","stop","stream_options","temperature","tool_choice","tool_prompt","tools","top_logprobs","top_p","extra_body"],"arg_types":["huggingface_hub.inference._client.InferenceClient",{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputGrammarType"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputStreamOptions",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceClass",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceEnum"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chat_completion of InferenceClient","ret_type":{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutput"],"extra_attrs":null,"type_ref":"typing.Iterable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","messages","model","stream","frequency_penalty","logit_bias","logprobs","max_tokens","n","presence_penalty","response_format","seed","stop","stream_options","temperature","tool_choice","tool_prompt","tools","top_logprobs","top_p","extra_body"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.chat_completion","name":"chat_completion","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","messages","model","stream","frequency_penalty","logit_bias","logprobs","max_tokens","n","presence_penalty","response_format","seed","stop","stream_options","temperature","tool_choice","tool_prompt","tools","top_logprobs","top_p","extra_body"],"arg_types":["huggingface_hub.inference._client.InferenceClient",{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputGrammarType"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputStreamOptions",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceClass",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceEnum"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chat_completion of InferenceClient","ret_type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutput",{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutput"],"extra_attrs":null,"type_ref":"typing.Iterable"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._client.InferenceClient.chat_completion","name":"chat_completion","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","messages","model","stream","frequency_penalty","logit_bias","logprobs","max_tokens","n","presence_penalty","response_format","seed","stop","stream_options","temperature","tool_choice","tool_prompt","tools","top_logprobs","top_p","extra_body"],"arg_types":["huggingface_hub.inference._client.InferenceClient",{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputGrammarType"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputStreamOptions",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceClass",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceEnum"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chat_completion of InferenceClient","ret_type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutput",{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutput"],"extra_attrs":null,"type_ref":"typing.Iterable"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","messages","model","stream","frequency_penalty","logit_bias","logprobs","max_tokens","n","presence_penalty","response_format","seed","stop","stream_options","temperature","tool_choice","tool_prompt","tools","top_logprobs","top_p","extra_body"],"arg_types":["huggingface_hub.inference._client.InferenceClient",{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputGrammarType"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputStreamOptions",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceClass",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceEnum"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chat_completion of InferenceClient","ret_type":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutput","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","messages","model","stream","frequency_penalty","logit_bias","logprobs","max_tokens","n","presence_penalty","response_format","seed","stop","stream_options","temperature","tool_choice","tool_prompt","tools","top_logprobs","top_p","extra_body"],"arg_types":["huggingface_hub.inference._client.InferenceClient",{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputGrammarType"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputStreamOptions",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceClass",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceEnum"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chat_completion of InferenceClient","ret_type":{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutput"],"extra_attrs":null,"type_ref":"typing.Iterable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","messages","model","stream","frequency_penalty","logit_bias","logprobs","max_tokens","n","presence_penalty","response_format","seed","stop","stream_options","temperature","tool_choice","tool_prompt","tools","top_logprobs","top_p","extra_body"],"arg_types":["huggingface_hub.inference._client.InferenceClient",{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputGrammarType"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputStreamOptions",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceClass",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceEnum"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chat_completion of InferenceClient","ret_type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutput",{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutput"],"extra_attrs":null,"type_ref":"typing.Iterable"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"close":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._client.InferenceClient.close","name":"close","original_first_arg":"self","type":null}},"cookies":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._client.InferenceClient.cookies","name":"cookies","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"document_question_answering":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5,5,5,5,5,5,5,5,5],"arg_names":["self","image","question","model","doc_stride","handle_impossible_answer","lang","max_answer_len","max_question_len","max_seq_len","top_k","word_boxes"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.document_question_answering","name":"document_question_answering","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,5,5,5,5,5,5,5,5,5],"arg_names":["self","image","question","model","doc_stride","handle_impossible_answer","lang","max_answer_len","max_question_len","max_seq_len","top_k","word_boxes"],"arg_types":["huggingface_hub.inference._client.InferenceClient",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._common.ContentT"},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"builtins.list"},"builtins.str"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"document_question_answering of InferenceClient","ret_type":{".class":"Instance","args":["huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringOutputElement"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"exit_stack":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._client.InferenceClient.exit_stack","name":"exit_stack","setter_type":null,"type":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"contextlib.ExitStack"}}},"feature_extraction":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5],"arg_names":["self","text","normalize","prompt_name","truncate","truncation_direction","model"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.feature_extraction","name":"feature_extraction","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5],"arg_names":["self","text","normalize","prompt_name","truncate","truncation_direction","model"],"arg_types":["huggingface_hub.inference._client.InferenceClient","builtins.str",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"Left"},{".class":"LiteralType","fallback":"builtins.str","value":"Right"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"feature_extraction of InferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"fill_mask":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5],"arg_names":["self","text","model","targets","top_k"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.fill_mask","name":"fill_mask","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5],"arg_names":["self","text","model","targets","top_k"],"arg_types":["huggingface_hub.inference._client.InferenceClient","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fill_mask of InferenceClient","ret_type":{".class":"Instance","args":["huggingface_hub.inference._generated.types.fill_mask.FillMaskOutputElement"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_endpoint_info":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5],"arg_names":["self","model"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.get_endpoint_info","name":"get_endpoint_info","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5],"arg_names":["self","model"],"arg_types":["huggingface_hub.inference._client.InferenceClient",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_endpoint_info of InferenceClient","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"headers":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._client.InferenceClient.headers","name":"headers","setter_type":null,"type":{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"health_check":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","model"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.health_check","name":"health_check","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","model"],"arg_types":["huggingface_hub.inference._client.InferenceClient",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"health_check of InferenceClient","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"image_classification":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5],"arg_names":["self","image","model","function_to_apply","top_k"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.image_classification","name":"image_classification","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5],"arg_names":["self","image","model","function_to_apply","top_k"],"arg_types":["huggingface_hub.inference._client.InferenceClient",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._common.ContentT"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.image_classification.ImageClassificationOutputTransform"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"image_classification of InferenceClient","ret_type":{".class":"Instance","args":["huggingface_hub.inference._generated.types.image_classification.ImageClassificationOutputElement"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"image_segmentation":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5],"arg_names":["self","image","model","mask_threshold","overlap_mask_area_threshold","subtask","threshold"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.image_segmentation","name":"image_segmentation","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5],"arg_names":["self","image","model","mask_threshold","overlap_mask_area_threshold","subtask","threshold"],"arg_types":["huggingface_hub.inference._client.InferenceClient",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._common.ContentT"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationSubtask"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"image_segmentation of InferenceClient","ret_type":{".class":"Instance","args":["huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationOutputElement"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"image_to_image":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,5,5,5,5,5,4],"arg_names":["self","image","prompt","negative_prompt","num_inference_steps","guidance_scale","model","target_size","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.image_to_image","name":"image_to_image","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,5,5,5,5,5,4],"arg_names":["self","image","prompt","negative_prompt","num_inference_steps","guidance_scale","model","target_size","kwargs"],"arg_types":["huggingface_hub.inference._client.InferenceClient",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._common.ContentT"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.image_to_image.ImageToImageTargetSize",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"image_to_image of InferenceClient","ret_type":"PIL.Image.Image","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"image_to_text":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5],"arg_names":["self","image","model"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.image_to_text","name":"image_to_text","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["self","image","model"],"arg_types":["huggingface_hub.inference._client.InferenceClient",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._common.ContentT"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"image_to_text of InferenceClient","ret_type":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextOutput","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"image_to_video":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5,5,5,5,4],"arg_names":["self","image","model","prompt","negative_prompt","num_frames","num_inference_steps","guidance_scale","seed","target_size","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.image_to_video","name":"image_to_video","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,4],"arg_names":["self","image","model","prompt","negative_prompt","num_frames","num_inference_steps","guidance_scale","seed","target_size","kwargs"],"arg_types":["huggingface_hub.inference._client.InferenceClient",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._common.ContentT"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.image_to_video.ImageToVideoTargetSize",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"image_to_video of InferenceClient","ret_type":"builtins.bytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"model":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"huggingface_hub.inference._client.InferenceClient.model","name":"model","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"object_detection":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5],"arg_names":["self","image","model","threshold"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.object_detection","name":"object_detection","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5],"arg_names":["self","image","model","threshold"],"arg_types":["huggingface_hub.inference._client.InferenceClient",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._common.ContentT"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"object_detection of InferenceClient","ret_type":{".class":"Instance","args":["huggingface_hub.inference._generated.types.object_detection.ObjectDetectionOutputElement"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"provider":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._client.InferenceClient.provider","name":"provider","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._providers.PROVIDER_OR_POLICY_T"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"question_answering":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5,5,5,5,5,5,5,5],"arg_names":["self","question","context","model","align_to_words","doc_stride","handle_impossible_answer","max_answer_len","max_question_len","max_seq_len","top_k"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.question_answering","name":"question_answering","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,5,5,5,5,5,5,5,5],"arg_names":["self","question","context","model","align_to_words","doc_stride","handle_impossible_answer","max_answer_len","max_question_len","max_seq_len","top_k"],"arg_types":["huggingface_hub.inference._client.InferenceClient","builtins.str","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"question_answering of InferenceClient","ret_type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringOutputElement",{".class":"Instance","args":["huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringOutputElement"],"extra_attrs":null,"type_ref":"builtins.list"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"sentence_similarity":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5],"arg_names":["self","sentence","other_sentences","model"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.sentence_similarity","name":"sentence_similarity","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,5],"arg_names":["self","sentence","other_sentences","model"],"arg_types":["huggingface_hub.inference._client.InferenceClient","builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sentence_similarity of InferenceClient","ret_type":{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"summarization":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5],"arg_names":["self","text","model","clean_up_tokenization_spaces","generate_parameters","truncation"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.summarization","name":"summarization","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5],"arg_names":["self","text","model","clean_up_tokenization_spaces","generate_parameters","truncation"],"arg_types":["huggingface_hub.inference._client.InferenceClient","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.summarization.SummarizationTruncationStrategy"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"summarization of InferenceClient","ret_type":"huggingface_hub.inference._generated.types.summarization.SummarizationOutput","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"table_question_answering":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5,5,5,5],"arg_names":["self","table","query","model","padding","sequential","truncation"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.table_question_answering","name":"table_question_answering","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,5,5,5,5],"arg_names":["self","table","query","model","padding","sequential","truncation"],"arg_types":["huggingface_hub.inference._client.InferenceClient",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.table_question_answering.Padding"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"table_question_answering of InferenceClient","ret_type":"huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringOutputElement","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"tabular_classification":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5],"arg_names":["self","table","model"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.tabular_classification","name":"tabular_classification","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["self","table","model"],"arg_types":["huggingface_hub.inference._client.InferenceClient",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tabular_classification of InferenceClient","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"tabular_regression":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5],"arg_names":["self","table","model"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.tabular_regression","name":"tabular_regression","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["self","table","model"],"arg_types":["huggingface_hub.inference._client.InferenceClient",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tabular_regression of InferenceClient","ret_type":{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"text_classification":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5],"arg_names":["self","text","model","top_k","function_to_apply"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.text_classification","name":"text_classification","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5],"arg_names":["self","text","model","top_k","function_to_apply"],"arg_types":["huggingface_hub.inference._client.InferenceClient","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.text_classification.TextClassificationOutputTransform"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_classification of InferenceClient","ret_type":{".class":"Instance","args":["huggingface_hub.inference._generated.types.text_classification.TextClassificationOutputElement"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"text_generation":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._client.InferenceClient.text_generation","impl":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.text_generation","name":"text_generation","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"arg_types":["huggingface_hub.inference._client.InferenceClient","builtins.str",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_generation of InferenceClient","ret_type":{".class":"UnionType","items":["builtins.str","huggingface_hub.inference._generated.types.text_generation.TextGenerationOutput",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"Instance","args":["huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutput"],"extra_attrs":null,"type_ref":"typing.Iterable"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,3,3,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.text_generation","name":"text_generation","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,3,3,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"arg_types":["huggingface_hub.inference._client.InferenceClient","builtins.str",{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_generation of InferenceClient","ret_type":{".class":"Instance","args":["huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutput"],"extra_attrs":null,"type_ref":"typing.Iterable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._client.InferenceClient.text_generation","name":"text_generation","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,3,3,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"arg_types":["huggingface_hub.inference._client.InferenceClient","builtins.str",{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_generation of InferenceClient","ret_type":{".class":"Instance","args":["huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutput"],"extra_attrs":null,"type_ref":"typing.Iterable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,3,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.text_generation","name":"text_generation","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,3,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"arg_types":["huggingface_hub.inference._client.InferenceClient","builtins.str",{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_generation of InferenceClient","ret_type":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutput","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._client.InferenceClient.text_generation","name":"text_generation","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,3,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"arg_types":["huggingface_hub.inference._client.InferenceClient","builtins.str",{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_generation of InferenceClient","ret_type":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutput","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,3,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.text_generation","name":"text_generation","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,3,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"arg_types":["huggingface_hub.inference._client.InferenceClient","builtins.str",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_generation of InferenceClient","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._client.InferenceClient.text_generation","name":"text_generation","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5,3,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"arg_types":["huggingface_hub.inference._client.InferenceClient","builtins.str",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_generation of InferenceClient","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.text_generation","name":"text_generation","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"arg_types":["huggingface_hub.inference._client.InferenceClient","builtins.str",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_generation of InferenceClient","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._client.InferenceClient.text_generation","name":"text_generation","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"arg_types":["huggingface_hub.inference._client.InferenceClient","builtins.str",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_generation of InferenceClient","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.text_generation","name":"text_generation","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"arg_types":["huggingface_hub.inference._client.InferenceClient","builtins.str",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_generation of InferenceClient","ret_type":{".class":"UnionType","items":["builtins.str","huggingface_hub.inference._generated.types.text_generation.TextGenerationOutput",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"Instance","args":["huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutput"],"extra_attrs":null,"type_ref":"typing.Iterable"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._client.InferenceClient.text_generation","name":"text_generation","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"arg_types":["huggingface_hub.inference._client.InferenceClient","builtins.str",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_generation of InferenceClient","ret_type":{".class":"UnionType","items":["builtins.str","huggingface_hub.inference._generated.types.text_generation.TextGenerationOutput",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"Instance","args":["huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutput"],"extra_attrs":null,"type_ref":"typing.Iterable"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,3,3,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"arg_types":["huggingface_hub.inference._client.InferenceClient","builtins.str",{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_generation of InferenceClient","ret_type":{".class":"Instance","args":["huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutput"],"extra_attrs":null,"type_ref":"typing.Iterable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,3,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"arg_types":["huggingface_hub.inference._client.InferenceClient","builtins.str",{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_generation of InferenceClient","ret_type":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutput","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,5,3,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"arg_types":["huggingface_hub.inference._client.InferenceClient","builtins.str",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_generation of InferenceClient","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"arg_types":["huggingface_hub.inference._client.InferenceClient","builtins.str",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_generation of InferenceClient","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"arg_types":["huggingface_hub.inference._client.InferenceClient","builtins.str",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_generation of InferenceClient","ret_type":{".class":"UnionType","items":["builtins.str","huggingface_hub.inference._generated.types.text_generation.TextGenerationOutput",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"Instance","args":["huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutput"],"extra_attrs":null,"type_ref":"typing.Iterable"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"text_to_image":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","negative_prompt","height","width","num_inference_steps","guidance_scale","model","scheduler","seed","extra_body"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.text_to_image","name":"text_to_image","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","negative_prompt","height","width","num_inference_steps","guidance_scale","model","scheduler","seed","extra_body"],"arg_types":["huggingface_hub.inference._client.InferenceClient","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_to_image of InferenceClient","ret_type":"PIL.Image.Image","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"text_to_speech":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","text","model","do_sample","early_stopping","epsilon_cutoff","eta_cutoff","max_length","max_new_tokens","min_length","min_new_tokens","num_beam_groups","num_beams","penalty_alpha","temperature","top_k","top_p","typical_p","use_cache","extra_body"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.text_to_speech","name":"text_to_speech","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","text","model","do_sample","early_stopping","epsilon_cutoff","eta_cutoff","max_length","max_new_tokens","min_length","min_new_tokens","num_beam_groups","num_beams","penalty_alpha","temperature","top_k","top_p","typical_p","use_cache","extra_body"],"arg_types":["huggingface_hub.inference._client.InferenceClient","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechEarlyStoppingEnum"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_to_speech of InferenceClient","ret_type":"builtins.bytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"text_to_video":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5,5,5],"arg_names":["self","prompt","model","guidance_scale","negative_prompt","num_frames","num_inference_steps","seed","extra_body"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.text_to_video","name":"text_to_video","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5],"arg_names":["self","prompt","model","guidance_scale","negative_prompt","num_frames","num_inference_steps","seed","extra_body"],"arg_types":["huggingface_hub.inference._client.InferenceClient","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_to_video of InferenceClient","ret_type":"builtins.bytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"timeout":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._client.InferenceClient.timeout","name":"timeout","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"token":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"huggingface_hub.inference._client.InferenceClient.token","name":"token","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"token_classification":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5],"arg_names":["self","text","model","aggregation_strategy","ignore_labels","stride"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.token_classification","name":"token_classification","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5],"arg_names":["self","text","model","aggregation_strategy","ignore_labels","stride"],"arg_types":["huggingface_hub.inference._client.InferenceClient","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.token_classification.TokenClassificationAggregationStrategy"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"token_classification of InferenceClient","ret_type":{".class":"Instance","args":["huggingface_hub.inference._generated.types.token_classification.TokenClassificationOutputElement"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"translation":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5,5],"arg_names":["self","text","model","src_lang","tgt_lang","clean_up_tokenization_spaces","truncation","generate_parameters"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.translation","name":"translation","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5],"arg_names":["self","text","model","src_lang","tgt_lang","clean_up_tokenization_spaces","truncation","generate_parameters"],"arg_types":["huggingface_hub.inference._client.InferenceClient","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.translation.TranslationTruncationStrategy"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"translation of InferenceClient","ret_type":"huggingface_hub.inference._generated.types.translation.TranslationOutput","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"visual_question_answering":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5,5],"arg_names":["self","image","question","model","top_k"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.visual_question_answering","name":"visual_question_answering","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,5,5],"arg_names":["self","image","question","model","top_k"],"arg_types":["huggingface_hub.inference._client.InferenceClient",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._common.ContentT"},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"visual_question_answering of InferenceClient","ret_type":{".class":"Instance","args":["huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringOutputElement"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"zero_shot_classification":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5,5,5],"arg_names":["self","text","candidate_labels","multi_label","hypothesis_template","model"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.zero_shot_classification","name":"zero_shot_classification","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,5,5,5],"arg_names":["self","text","candidate_labels","multi_label","hypothesis_template","model"],"arg_types":["huggingface_hub.inference._client.InferenceClient","builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zero_shot_classification of InferenceClient","ret_type":{".class":"Instance","args":["huggingface_hub.inference._generated.types.zero_shot_classification.ZeroShotClassificationOutputElement"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"zero_shot_image_classification":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5,5,5],"arg_names":["self","image","candidate_labels","model","hypothesis_template","labels"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._client.InferenceClient.zero_shot_image_classification","name":"zero_shot_image_classification","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,5,5,5],"arg_names":["self","image","candidate_labels","model","hypothesis_template","labels"],"arg_types":["huggingface_hub.inference._client.InferenceClient",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._common.ContentT"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zero_shot_image_classification of InferenceClient","ret_type":{".class":"Instance","args":["huggingface_hub.inference._generated.types.zero_shot_image_classification.ZeroShotImageClassificationOutputElement"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._client.InferenceClient.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._client.InferenceClient","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"InferenceTimeoutError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.InferenceTimeoutError","kind":"Gdef"},"Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"MODEL_KWARGS_NOT_USED_REGEX":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.inference._client.MODEL_KWARGS_NOT_USED_REGEX","name":"MODEL_KWARGS_NOT_USED_REGEX","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"ObjectDetectionOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.object_detection.ObjectDetectionOutputElement","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"PROVIDER_OR_POLICY_T":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.PROVIDER_OR_POLICY_T","kind":"Gdef"},"Padding":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.table_question_answering.Padding","kind":"Gdef"},"ProxyClientChat":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._client._ProxyClient"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._client.ProxyClientChat","name":"ProxyClientChat","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._client.ProxyClientChat","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._client","mro":["huggingface_hub.inference._client.ProxyClientChat","huggingface_hub.inference._client._ProxyClient","builtins.object"],"names":{".class":"SymbolTable","completions":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.inference._client.ProxyClientChat.completions","name":"completions","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.inference._client.ProxyClientChat"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"completions of ProxyClientChat","ret_type":"huggingface_hub.inference._client.ProxyClientChatCompletions","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"huggingface_hub.inference._client.ProxyClientChat.completions","name":"completions","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.inference._client.ProxyClientChat"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"completions of ProxyClientChat","ret_type":"huggingface_hub.inference._client.ProxyClientChatCompletions","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._client.ProxyClientChat.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._client.ProxyClientChat","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ProxyClientChatCompletions":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._client._ProxyClient"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._client.ProxyClientChatCompletions","name":"ProxyClientChatCompletions","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._client.ProxyClientChatCompletions","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._client","mro":["huggingface_hub.inference._client.ProxyClientChatCompletions","huggingface_hub.inference._client._ProxyClient","builtins.object"],"names":{".class":"SymbolTable","create":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated"],"fullname":"huggingface_hub.inference._client.ProxyClientChatCompletions.create","name":"create","original_first_arg":"self","type":null},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"huggingface_hub.inference._client.ProxyClientChatCompletions.create","name":"create","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.inference._client.ProxyClientChatCompletions"],"fallback":"builtins.function","from_concatenate":false,"implicit":true,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"create of ProxyClientChatCompletions","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._client.ProxyClientChatCompletions.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._client.ProxyClientChatCompletions","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"QuestionAnsweringOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringOutputElement","kind":"Gdef"},"RequestParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common.RequestParameters","kind":"Gdef"},"SummarizationOutput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.summarization.SummarizationOutput","kind":"Gdef"},"SummarizationTruncationStrategy":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.summarization.SummarizationTruncationStrategy","kind":"Gdef"},"TASKS_EXPECTING_IMAGES":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common.TASKS_EXPECTING_IMAGES","kind":"Gdef"},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"TableQuestionAnsweringOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringOutputElement","kind":"Gdef"},"TextClassificationOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_classification.TextClassificationOutputElement","kind":"Gdef"},"TextClassificationOutputTransform":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_classification.TextClassificationOutputTransform","kind":"Gdef"},"TextGenerationInputGrammarType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType","kind":"Gdef"},"TextGenerationOutput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutput","kind":"Gdef"},"TextGenerationStreamOutput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutput","kind":"Gdef"},"TextToSpeechEarlyStoppingEnum":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechEarlyStoppingEnum","kind":"Gdef"},"TokenClassificationAggregationStrategy":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.token_classification.TokenClassificationAggregationStrategy","kind":"Gdef"},"TokenClassificationOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.token_classification.TokenClassificationOutputElement","kind":"Gdef"},"TranslationOutput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.translation.TranslationOutput","kind":"Gdef"},"TranslationTruncationStrategy":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.translation.TranslationTruncationStrategy","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"VisualQuestionAnsweringOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringOutputElement","kind":"Gdef"},"ZeroShotClassificationOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.zero_shot_classification.ZeroShotClassificationOutputElement","kind":"Gdef"},"ZeroShotImageClassificationOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.zero_shot_image_classification.ZeroShotImageClassificationOutputElement","kind":"Gdef"},"_ProxyClient":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._client._ProxyClient","name":"_ProxyClient","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._client._ProxyClient","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._client","mro":["huggingface_hub.inference._client._ProxyClient","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","client"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._client._ProxyClient.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","client"],"arg_types":["huggingface_hub.inference._client._ProxyClient","huggingface_hub.inference._client.InferenceClient"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of _ProxyClient","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_client":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._client._ProxyClient._client","name":"_client","setter_type":null,"type":"huggingface_hub.inference._client.InferenceClient"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._client._ProxyClient.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._client._ProxyClient","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._client.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._client.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._client.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._client.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._client.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._client.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_b64_encode":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._b64_encode","kind":"Gdef"},"_b64_to_image":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._b64_to_image","kind":"Gdef"},"_bytes_to_dict":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._bytes_to_dict","kind":"Gdef"},"_bytes_to_image":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._bytes_to_image","kind":"Gdef"},"_bytes_to_list":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._bytes_to_list","kind":"Gdef"},"_get_unsupported_text_generation_kwargs":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._get_unsupported_text_generation_kwargs","kind":"Gdef"},"_import_numpy":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._import_numpy","kind":"Gdef"},"_set_unsupported_text_generation_kwargs":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._set_unsupported_text_generation_kwargs","kind":"Gdef"},"_stream_chat_completion_response":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._stream_chat_completion_response","kind":"Gdef"},"_stream_text_generation_response":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._stream_text_generation_response","kind":"Gdef"},"base64":{".class":"SymbolTableNode","cross_ref":"base64","kind":"Gdef"},"build_hf_headers":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._headers.build_hf_headers","kind":"Gdef"},"constants":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.constants","kind":"Gdef"},"get_provider_helper":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.get_provider_helper","kind":"Gdef"},"get_session":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._http.get_session","kind":"Gdef"},"get_token":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._auth.get_token","kind":"Gdef"},"hf_raise_for_status":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._http.hf_raise_for_status","kind":"Gdef"},"logger":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.inference._client.logger","name":"logger","setter_type":null,"type":"logging.Logger"}},"logging":{".class":"SymbolTableNode","cross_ref":"logging","kind":"Gdef"},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef"},"os":{".class":"SymbolTableNode","cross_ref":"os","kind":"Gdef"},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef"},"raise_text_generation_error":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common.raise_text_generation_error","kind":"Gdef"},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef"},"validate_hf_hub_args":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._validators.validate_hf_hub_args","kind":"Gdef"},"warnings":{".class":"SymbolTableNode","cross_ref":"warnings","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_client.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_client.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_client.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..ba5688c0d1846c6c24aaf1c2bfd9efe1b7a7f4d5 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_client.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[61,45,103,110,43,44,104,115,35,36,37,38,39,40,41,43,114,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],"dep_prios":[5,5,5,5,10,5,5,25,10,10,10,10,10,5,5,20,25,5,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30],"dependencies":["huggingface_hub.inference._generated.types","huggingface_hub.inference._common","huggingface_hub.inference._providers","huggingface_hub.utils._auth","huggingface_hub.constants","huggingface_hub.errors","huggingface_hub.utils","PIL.Image","base64","logging","os","re","warnings","contextlib","typing","huggingface_hub","numpy","builtins","PIL","_frozen_importlib","_warnings","abc","enum","huggingface_hub.inference._generated","huggingface_hub.inference._generated.types.audio_classification","huggingface_hub.inference._generated.types.audio_to_audio","huggingface_hub.inference._generated.types.automatic_speech_recognition","huggingface_hub.inference._generated.types.base","huggingface_hub.inference._generated.types.chat_completion","huggingface_hub.inference._generated.types.document_question_answering","huggingface_hub.inference._generated.types.fill_mask","huggingface_hub.inference._generated.types.image_classification","huggingface_hub.inference._generated.types.image_segmentation","huggingface_hub.inference._generated.types.image_to_image","huggingface_hub.inference._generated.types.image_to_text","huggingface_hub.inference._generated.types.image_to_video","huggingface_hub.inference._generated.types.object_detection","huggingface_hub.inference._generated.types.question_answering","huggingface_hub.inference._generated.types.summarization","huggingface_hub.inference._generated.types.table_question_answering","huggingface_hub.inference._generated.types.text_classification","huggingface_hub.inference._generated.types.text_generation","huggingface_hub.inference._generated.types.token_classification","huggingface_hub.inference._generated.types.translation","huggingface_hub.inference._generated.types.visual_question_answering","huggingface_hub.inference._generated.types.zero_shot_classification","huggingface_hub.inference._generated.types.zero_shot_image_classification","huggingface_hub.utils._validators","pathlib"],"hash":"2d662bce3e57ea0a59566d9d787fae8cf248dc35","id":"huggingface_hub.inference._client","ignore_all":true,"interface_hash":"4d05398ba11397a4cb16d9035f1c4d4bc7180ca3","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_client.py","plugin_data":null,"size":158079,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_common.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_common.data.json new file mode 100644 index 0000000000000000000000000000000000000000..f77f11347ed4528c92bd8d136db27542c62d16fc --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_common.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._common","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"AsyncIterable":{".class":"SymbolTableNode","cross_ref":"typing.AsyncIterable","kind":"Gdef"},"BinaryIO":{".class":"SymbolTableNode","cross_ref":"typing.BinaryIO","kind":"Gdef"},"ChatCompletionStreamOutput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutput","kind":"Gdef"},"ContentT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.inference._common.ContentT","line":48,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["builtins.bytes","typing.BinaryIO",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._common.PathT"},"builtins.str","PIL.Image.Image","builtins.bytearray",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.memoryview"}],"uses_pep604_syntax":false}}},"GenerationError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.GenerationError","kind":"Gdef"},"HfHubHTTPError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.HfHubHTTPError","kind":"Gdef"},"Image":{".class":"SymbolTableNode","cross_ref":"PIL.Image.Image","kind":"Gdef"},"IncompleteGenerationError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.IncompleteGenerationError","kind":"Gdef"},"Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"MimeBytes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.bytes"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._common.MimeBytes","name":"MimeBytes","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._common.MimeBytes","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._common","mro":["huggingface_hub.inference._common.MimeBytes","builtins.bytes","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","__new__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["cls","data","mime_type"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_trivial_self"],"fullname":"huggingface_hub.inference._common.MimeBytes.__new__","name":"__new__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["cls","data","mime_type"],"arg_types":[{".class":"TypeType","item":"huggingface_hub.inference._common.MimeBytes"},"builtins.bytes",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of MimeBytes","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"mime_type":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._common.MimeBytes.mime_type","name":"mime_type","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._common.MimeBytes.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._common.MimeBytes","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"NoReturn":{".class":"SymbolTableNode","cross_ref":"typing.NoReturn","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"OverloadedError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.OverloadedError","kind":"Gdef"},"Path":{".class":"SymbolTableNode","cross_ref":"pathlib.Path","kind":"Gdef"},"PathT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.inference._common.PathT","line":47,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["builtins.str","pathlib.Path"],"uses_pep604_syntax":false}}},"RequestParameters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._common.RequestParameters","name":"RequestParameters","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._common.RequestParameters","has_param_spec_type":false,"metaclass_type":null,"metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":58,"name":"url","type":"builtins.str"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":59,"name":"task","type":"builtins.str"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":60,"name":"model","type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":61,"name":"json","type":{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":62,"name":"data","type":{".class":"UnionType","items":["builtins.bytes",{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":63,"name":"headers","type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}}],"frozen":false},"dataclass_tag":{}},"module_name":"huggingface_hub.inference._common","mro":["huggingface_hub.inference._common.RequestParameters","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"huggingface_hub.inference._common.RequestParameters.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"dataclasses.Field"}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0,0,0],"arg_names":["self","url","task","model","json","data","headers"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._common.RequestParameters.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,0],"arg_names":["self","url","task","model","json","data","headers"],"arg_types":["huggingface_hub.inference._common.RequestParameters","builtins.str","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bytes",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of RequestParameters","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5],"arg_names":["url","task","model","json","data","headers"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"huggingface_hub.inference._common.RequestParameters.__mypy-replace","name":"__mypy-replace","original_first_arg":"url","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5],"arg_names":["url","task","model","json","data","headers"],"arg_types":["builtins.str","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bytes",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of RequestParameters","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"huggingface_hub.inference._common.RequestParameters.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5],"arg_names":["url","task","model","json","data","headers"],"arg_types":["builtins.str","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bytes",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of RequestParameters","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"data":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._common.RequestParameters.data","name":"data","setter_type":null,"type":{".class":"UnionType","items":["builtins.bytes",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"headers":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._common.RequestParameters.headers","name":"headers","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"json":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._common.RequestParameters.json","name":"json","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"model":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._common.RequestParameters.model","name":"model","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"task":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._common.RequestParameters.task","name":"task","setter_type":null,"type":"builtins.str"}},"url":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._common.RequestParameters.url","name":"url","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._common.RequestParameters.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._common.RequestParameters","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TASKS_EXPECTING_IMAGES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.inference._common.TASKS_EXPECTING_IMAGES","name":"TASKS_EXPECTING_IMAGES","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"TextGenerationError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.TextGenerationError","kind":"Gdef"},"TextGenerationStreamOutput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutput","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"UnknownError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.UnknownError","kind":"Gdef"},"UrlT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.inference._common.UrlT","line":46,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":"builtins.str"}},"ValidationError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.ValidationError","kind":"Gdef"},"_UNSUPPORTED_TEXT_GENERATION_KWARGS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._common._UNSUPPORTED_TEXT_GENERATION_KWARGS","name":"_UNSUPPORTED_TEXT_GENERATION_KWARGS","setter_type":null,"type":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._common.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._common.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._common.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._common.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._common.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._common.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_as_dict":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["response"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._common._as_dict","name":"_as_dict","original_first_arg":"response","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["response"],"arg_types":[{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_as_dict","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_as_url":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["content","default_mime_type"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._common._as_url","name":"_as_url","original_first_arg":"content","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["content","default_mime_type"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._common.ContentT"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_as_url","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_async_stream_chat_completion_response":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["lines"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_generator","is_coroutine","is_async_generator"],"fullname":"huggingface_hub.inference._common._async_stream_chat_completion_response","name":"_async_stream_chat_completion_response","original_first_arg":"lines","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["lines"],"arg_types":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.AsyncIterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_async_stream_chat_completion_response","ret_type":{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutput"],"extra_attrs":null,"type_ref":"typing.AsyncIterable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_async_stream_text_generation_response":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["output_lines","details"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_generator","is_coroutine","is_async_generator"],"fullname":"huggingface_hub.inference._common._async_stream_text_generation_response","name":"_async_stream_text_generation_response","original_first_arg":"output_lines","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["output_lines","details"],"arg_types":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.AsyncIterable"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_async_stream_text_generation_response","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.AsyncIterable"},{".class":"Instance","args":["huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutput"],"extra_attrs":null,"type_ref":"typing.AsyncIterable"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_async_yield_from":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["client","response"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_generator","is_coroutine","is_async_generator"],"fullname":"huggingface_hub.inference._common._async_yield_from","name":"_async_yield_from","original_first_arg":"client","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["client","response"],"arg_types":["httpx._client.AsyncClient","httpx._models.Response"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_async_yield_from","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.AsyncIterable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_b64_encode":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["content"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._common._b64_encode","name":"_b64_encode","original_first_arg":"content","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["content"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._common.ContentT"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_b64_encode","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_b64_to_image":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["encoded_image"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._common._b64_to_image","name":"_b64_to_image","original_first_arg":"encoded_image","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["encoded_image"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_b64_to_image","ret_type":"PIL.Image.Image","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_bytes_to_dict":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["content"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._common._bytes_to_dict","name":"_bytes_to_dict","original_first_arg":"content","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["content"],"arg_types":["builtins.bytes"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_bytes_to_dict","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_bytes_to_image":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["content"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._common._bytes_to_image","name":"_bytes_to_image","original_first_arg":"content","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["content"],"arg_types":["builtins.bytes"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_bytes_to_image","ret_type":"PIL.Image.Image","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_bytes_to_list":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["content"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._common._bytes_to_list","name":"_bytes_to_list","original_first_arg":"content","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["content"],"arg_types":["builtins.bytes"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_bytes_to_list","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_format_chat_completion_stream_output":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["line"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._common._format_chat_completion_stream_output","name":"_format_chat_completion_stream_output","original_first_arg":"line","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["line"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_format_chat_completion_stream_output","ret_type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutput",{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_format_text_generation_stream_output":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["line","details"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._common._format_text_generation_stream_output","name":"_format_text_generation_stream_output","original_first_arg":"line","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["line","details"],"arg_types":["builtins.str","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_format_text_generation_stream_output","ret_type":{".class":"UnionType","items":["builtins.str","huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutput",{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_get_unsupported_text_generation_kwargs":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["model"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._common._get_unsupported_text_generation_kwargs","name":"_get_unsupported_text_generation_kwargs","original_first_arg":"model","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["model"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_unsupported_text_generation_kwargs","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_import_numpy":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._common._import_numpy","name":"_import_numpy","original_first_arg":null,"type":null}},"_import_pil_image":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._common._import_pil_image","name":"_import_pil_image","original_first_arg":null,"type":null}},"_open_as_mime_bytes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._common._open_as_mime_bytes","impl":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["content"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload"],"fullname":"huggingface_hub.inference._common._open_as_mime_bytes","name":"_open_as_mime_bytes","original_first_arg":"content","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["content"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._common.ContentT"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_open_as_mime_bytes","ret_type":{".class":"UnionType","items":["huggingface_hub.inference._common.MimeBytes",{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["content"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"huggingface_hub.inference._common._open_as_mime_bytes","name":"_open_as_mime_bytes","original_first_arg":"content","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["content"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._common.ContentT"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_open_as_mime_bytes","ret_type":"huggingface_hub.inference._common.MimeBytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._common._open_as_mime_bytes","name":"_open_as_mime_bytes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["content"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._common.ContentT"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_open_as_mime_bytes","ret_type":"huggingface_hub.inference._common.MimeBytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["content"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"huggingface_hub.inference._common._open_as_mime_bytes","name":"_open_as_mime_bytes","original_first_arg":"content","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["content"],"arg_types":[{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_open_as_mime_bytes","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._common._open_as_mime_bytes","name":"_open_as_mime_bytes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["content"],"arg_types":[{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_open_as_mime_bytes","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["content"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._common.ContentT"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_open_as_mime_bytes","ret_type":"huggingface_hub.inference._common.MimeBytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["content"],"arg_types":[{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_open_as_mime_bytes","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"_parse_text_generation_error":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["error","error_type"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._common._parse_text_generation_error","name":"_parse_text_generation_error","original_first_arg":"error","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["error","error_type"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_parse_text_generation_error","ret_type":"huggingface_hub.errors.TextGenerationError","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_set_unsupported_text_generation_kwargs":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["model","unsupported_kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._common._set_unsupported_text_generation_kwargs","name":"_set_unsupported_text_generation_kwargs","original_first_arg":"model","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["model","unsupported_kwargs"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_set_unsupported_text_generation_kwargs","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_stream_chat_completion_response":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["lines"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._common._stream_chat_completion_response","name":"_stream_chat_completion_response","original_first_arg":"lines","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["lines"],"arg_types":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_stream_chat_completion_response","ret_type":{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutput"],"extra_attrs":null,"type_ref":"typing.Iterable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_stream_text_generation_response":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["output_lines","details"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._common._stream_text_generation_response","name":"_stream_text_generation_response","original_first_arg":"output_lines","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["output_lines","details"],"arg_types":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_stream_text_generation_response","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"Instance","args":["huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutput"],"extra_attrs":null,"type_ref":"typing.Iterable"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"base64":{".class":"SymbolTableNode","cross_ref":"base64","kind":"Gdef"},"dataclass":{".class":"SymbolTableNode","cross_ref":"dataclasses.dataclass","kind":"Gdef"},"get_session":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._http.get_session","kind":"Gdef"},"httpx":{".class":"SymbolTableNode","cross_ref":"httpx","kind":"Gdef"},"io":{".class":"SymbolTableNode","cross_ref":"io","kind":"Gdef"},"is_numpy_available":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.is_numpy_available","kind":"Gdef"},"is_pillow_available":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.is_pillow_available","kind":"Gdef"},"json":{".class":"SymbolTableNode","cross_ref":"json","kind":"Gdef"},"logger":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.inference._common.logger","name":"logger","setter_type":null,"type":"logging.Logger"}},"logging":{".class":"SymbolTableNode","cross_ref":"logging","kind":"Gdef"},"mimetypes":{".class":"SymbolTableNode","cross_ref":"mimetypes","kind":"Gdef"},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef"},"raise_text_generation_error":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["http_error"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._common.raise_text_generation_error","name":"raise_text_generation_error","original_first_arg":"http_error","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["http_error"],"arg_types":["huggingface_hub.errors.HfHubHTTPError"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"raise_text_generation_error","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_common.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_common.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_common.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..770fa507d66b5e0cfce0cd4b519d93ebbcc46558 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_common.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[39,28,38,43,17,18,19,20,21,22,23,24,26,1,1,1,1,1,1,1,1,1,1,1,1,1],"dep_prios":[5,5,5,25,10,10,10,10,10,5,5,5,10,5,30,30,30,30,30,30,30,30,30,30,30,30],"dependencies":["huggingface_hub.inference._generated.types","huggingface_hub.errors","huggingface_hub.utils","PIL.Image","base64","io","json","logging","mimetypes","dataclasses","pathlib","typing","httpx","builtins","PIL","_frozen_importlib","abc","httpx._client","httpx._exceptions","httpx._models","huggingface_hub.inference._generated","huggingface_hub.inference._generated.types.base","huggingface_hub.inference._generated.types.chat_completion","huggingface_hub.inference._generated.types.text_generation","os","typing_extensions"],"hash":"bef9c4df24e7796bfd7e07cc57f483a9942f226c","id":"huggingface_hub.inference._common","ignore_all":true,"interface_hash":"8d1c5feb93acd8d7b3bca8c04ad842e37aa9a83f","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_common.py","plugin_data":null,"size":15069,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..3862e977963f47dfc382d68eaf360e8505ae4937 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._generated","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/__init__.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..e9e88cbc6bca7afcb82ff18d93d4d584e30e9f92 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106714,"dep_lines":[1,1,1,1],"dep_prios":[5,30,30,30],"dependencies":["builtins","_frozen_importlib","abc","typing"],"hash":"da39a3ee5e6b4b0d3255bfef95601890afd80709","id":"huggingface_hub.inference._generated","ignore_all":true,"interface_hash":"5778612c0d3628adda6d7aa382cc7f33b92b2fd0","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/__init__.py","plugin_data":null,"size":0,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/_async_client.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/_async_client.data.json new file mode 100644 index 0000000000000000000000000000000000000000..8756fbe956bc385b76a0f8e89629d410824802d8 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/_async_client.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._generated._async_client","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"AsyncExitStack":{".class":"SymbolTableNode","cross_ref":"contextlib.AsyncExitStack","kind":"Gdef"},"AsyncInferenceClient":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient","name":"AsyncInferenceClient","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._generated._async_client","mro":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","builtins.object"],"names":{".class":"SymbolTable","__aenter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.__aenter__","name":"__aenter__","original_first_arg":"self","type":null}},"__aexit__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","exc_type","exc_value","traceback"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.__aexit__","name":"__aexit__","original_first_arg":"self","type":null}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,5,5,5,5,5,5,5,5],"arg_names":["self","model","provider","token","timeout","headers","cookies","bill_to","base_url","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,5,5,5,5,5,5,5,5],"arg_names":["self","model","provider","token","timeout","headers","cookies","bill_to","base_url","api_key"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._providers.PROVIDER_OR_POLICY_T"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of AsyncInferenceClient","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.__init__","name":"__init__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,5,5,5,5,5,5,5,5],"arg_names":["self","model","provider","token","timeout","headers","cookies","bill_to","base_url","api_key"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._providers.PROVIDER_OR_POLICY_T"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of AsyncInferenceClient","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.__repr__","name":"__repr__","original_first_arg":"self","type":null}},"_async_client":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient._async_client","name":"_async_client","setter_type":null,"type":{".class":"UnionType","items":["httpx._client.AsyncClient",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"_get_async_client":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient._get_async_client","name":"_get_async_client","original_first_arg":"self","type":null}},"_inner_post":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient._inner_post","impl":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5],"arg_names":["self","request_parameters","stream"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_coroutine","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient._inner_post","name":"_inner_post","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["self","request_parameters","stream"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","huggingface_hub.inference._common.RequestParameters","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_inner_post of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.AsyncIterable"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5],"arg_names":["self","request_parameters","stream"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_coroutine","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient._inner_post","name":"_inner_post","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["self","request_parameters","stream"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","huggingface_hub.inference._common.RequestParameters",{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_inner_post of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient._inner_post","name":"_inner_post","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["self","request_parameters","stream"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","huggingface_hub.inference._common.RequestParameters",{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_inner_post of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5],"arg_names":["self","request_parameters","stream"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_coroutine","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient._inner_post","name":"_inner_post","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["self","request_parameters","stream"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","huggingface_hub.inference._common.RequestParameters",{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_inner_post of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.AsyncIterable"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient._inner_post","name":"_inner_post","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["self","request_parameters","stream"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","huggingface_hub.inference._common.RequestParameters",{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_inner_post of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.AsyncIterable"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5],"arg_names":["self","request_parameters","stream"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_coroutine","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient._inner_post","name":"_inner_post","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["self","request_parameters","stream"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","huggingface_hub.inference._common.RequestParameters","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_inner_post of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.AsyncIterable"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient._inner_post","name":"_inner_post","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["self","request_parameters","stream"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","huggingface_hub.inference._common.RequestParameters","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_inner_post of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.AsyncIterable"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["self","request_parameters","stream"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","huggingface_hub.inference._common.RequestParameters",{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_inner_post of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["self","request_parameters","stream"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","huggingface_hub.inference._common.RequestParameters",{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_inner_post of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.AsyncIterable"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["self","request_parameters","stream"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","huggingface_hub.inference._common.RequestParameters","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_inner_post of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.AsyncIterable"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"audio_classification":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5],"arg_names":["self","audio","model","top_k","function_to_apply"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.audio_classification","name":"audio_classification","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5],"arg_names":["self","audio","model","top_k","function_to_apply"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._common.ContentT"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.audio_classification.AudioClassificationOutputTransform"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"audio_classification of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"Instance","args":["huggingface_hub.inference._generated.types.audio_classification.AudioClassificationOutputElement"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"audio_to_audio":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5],"arg_names":["self","audio","model"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.audio_to_audio","name":"audio_to_audio","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["self","audio","model"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._common.ContentT"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"audio_to_audio of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"Instance","args":["huggingface_hub.inference._generated.types.audio_to_audio.AudioToAudioOutputElement"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"automatic_speech_recognition":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5],"arg_names":["self","audio","model","extra_body"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.automatic_speech_recognition","name":"automatic_speech_recognition","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5],"arg_names":["self","audio","model","extra_body"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._common.ContentT"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"automatic_speech_recognition of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionOutput"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"chat":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.chat","name":"chat","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chat of AsyncInferenceClient","ret_type":"huggingface_hub.inference._generated._async_client.ProxyClientChat","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.chat","name":"chat","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chat of AsyncInferenceClient","ret_type":"huggingface_hub.inference._generated._async_client.ProxyClientChat","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"chat_completion":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.chat_completion","impl":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","messages","model","stream","frequency_penalty","logit_bias","logprobs","max_tokens","n","presence_penalty","response_format","seed","stop","stream_options","temperature","tool_choice","tool_prompt","tools","top_logprobs","top_p","extra_body"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_coroutine","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.chat_completion","name":"chat_completion","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","messages","model","stream","frequency_penalty","logit_bias","logprobs","max_tokens","n","presence_penalty","response_format","seed","stop","stream_options","temperature","tool_choice","tool_prompt","tools","top_logprobs","top_p","extra_body"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient",{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputGrammarType"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputStreamOptions",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceClass",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceEnum"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chat_completion of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutput",{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutput"],"extra_attrs":null,"type_ref":"typing.AsyncIterable"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","messages","model","stream","frequency_penalty","logit_bias","logprobs","max_tokens","n","presence_penalty","response_format","seed","stop","stream_options","temperature","tool_choice","tool_prompt","tools","top_logprobs","top_p","extra_body"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_coroutine","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.chat_completion","name":"chat_completion","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","messages","model","stream","frequency_penalty","logit_bias","logprobs","max_tokens","n","presence_penalty","response_format","seed","stop","stream_options","temperature","tool_choice","tool_prompt","tools","top_logprobs","top_p","extra_body"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient",{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputGrammarType"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputStreamOptions",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceClass",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceEnum"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chat_completion of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutput"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.chat_completion","name":"chat_completion","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","messages","model","stream","frequency_penalty","logit_bias","logprobs","max_tokens","n","presence_penalty","response_format","seed","stop","stream_options","temperature","tool_choice","tool_prompt","tools","top_logprobs","top_p","extra_body"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient",{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputGrammarType"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputStreamOptions",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceClass",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceEnum"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chat_completion of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutput"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","messages","model","stream","frequency_penalty","logit_bias","logprobs","max_tokens","n","presence_penalty","response_format","seed","stop","stream_options","temperature","tool_choice","tool_prompt","tools","top_logprobs","top_p","extra_body"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_coroutine","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.chat_completion","name":"chat_completion","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","messages","model","stream","frequency_penalty","logit_bias","logprobs","max_tokens","n","presence_penalty","response_format","seed","stop","stream_options","temperature","tool_choice","tool_prompt","tools","top_logprobs","top_p","extra_body"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient",{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputGrammarType"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputStreamOptions",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceClass",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceEnum"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chat_completion of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutput"],"extra_attrs":null,"type_ref":"typing.AsyncIterable"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.chat_completion","name":"chat_completion","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","messages","model","stream","frequency_penalty","logit_bias","logprobs","max_tokens","n","presence_penalty","response_format","seed","stop","stream_options","temperature","tool_choice","tool_prompt","tools","top_logprobs","top_p","extra_body"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient",{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputGrammarType"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputStreamOptions",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceClass",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceEnum"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chat_completion of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutput"],"extra_attrs":null,"type_ref":"typing.AsyncIterable"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","messages","model","stream","frequency_penalty","logit_bias","logprobs","max_tokens","n","presence_penalty","response_format","seed","stop","stream_options","temperature","tool_choice","tool_prompt","tools","top_logprobs","top_p","extra_body"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_coroutine","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.chat_completion","name":"chat_completion","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","messages","model","stream","frequency_penalty","logit_bias","logprobs","max_tokens","n","presence_penalty","response_format","seed","stop","stream_options","temperature","tool_choice","tool_prompt","tools","top_logprobs","top_p","extra_body"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient",{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputGrammarType"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputStreamOptions",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceClass",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceEnum"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chat_completion of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutput",{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutput"],"extra_attrs":null,"type_ref":"typing.AsyncIterable"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.chat_completion","name":"chat_completion","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","messages","model","stream","frequency_penalty","logit_bias","logprobs","max_tokens","n","presence_penalty","response_format","seed","stop","stream_options","temperature","tool_choice","tool_prompt","tools","top_logprobs","top_p","extra_body"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient",{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputGrammarType"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputStreamOptions",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceClass",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceEnum"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chat_completion of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutput",{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutput"],"extra_attrs":null,"type_ref":"typing.AsyncIterable"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","messages","model","stream","frequency_penalty","logit_bias","logprobs","max_tokens","n","presence_penalty","response_format","seed","stop","stream_options","temperature","tool_choice","tool_prompt","tools","top_logprobs","top_p","extra_body"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient",{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputGrammarType"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputStreamOptions",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceClass",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceEnum"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chat_completion of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutput"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","messages","model","stream","frequency_penalty","logit_bias","logprobs","max_tokens","n","presence_penalty","response_format","seed","stop","stream_options","temperature","tool_choice","tool_prompt","tools","top_logprobs","top_p","extra_body"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient",{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputGrammarType"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputStreamOptions",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceClass",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceEnum"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chat_completion of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutput"],"extra_attrs":null,"type_ref":"typing.AsyncIterable"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","messages","model","stream","frequency_penalty","logit_bias","logprobs","max_tokens","n","presence_penalty","response_format","seed","stop","stream_options","temperature","tool_choice","tool_prompt","tools","top_logprobs","top_p","extra_body"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient",{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputGrammarType"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputStreamOptions",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceClass",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceEnum"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chat_completion of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutput",{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutput"],"extra_attrs":null,"type_ref":"typing.AsyncIterable"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"close":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.close","name":"close","original_first_arg":"self","type":null}},"cookies":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.cookies","name":"cookies","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"document_question_answering":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5,5,5,5,5,5,5,5,5],"arg_names":["self","image","question","model","doc_stride","handle_impossible_answer","lang","max_answer_len","max_question_len","max_seq_len","top_k","word_boxes"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.document_question_answering","name":"document_question_answering","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,5,5,5,5,5,5,5,5,5],"arg_names":["self","image","question","model","doc_stride","handle_impossible_answer","lang","max_answer_len","max_question_len","max_seq_len","top_k","word_boxes"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._common.ContentT"},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"builtins.list"},"builtins.str"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"document_question_answering of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"Instance","args":["huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringOutputElement"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"exit_stack":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.exit_stack","name":"exit_stack","setter_type":null,"type":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"contextlib.AsyncExitStack"}}},"feature_extraction":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5],"arg_names":["self","text","normalize","prompt_name","truncate","truncation_direction","model"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.feature_extraction","name":"feature_extraction","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5],"arg_names":["self","text","normalize","prompt_name","truncate","truncation_direction","model"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","builtins.str",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"Left"},{".class":"LiteralType","fallback":"builtins.str","value":"Right"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"feature_extraction of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"fill_mask":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5],"arg_names":["self","text","model","targets","top_k"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.fill_mask","name":"fill_mask","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5],"arg_names":["self","text","model","targets","top_k"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fill_mask of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"Instance","args":["huggingface_hub.inference._generated.types.fill_mask.FillMaskOutputElement"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_endpoint_info":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5],"arg_names":["self","model"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.get_endpoint_info","name":"get_endpoint_info","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5],"arg_names":["self","model"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_endpoint_info of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"headers":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.headers","name":"headers","setter_type":null,"type":{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"health_check":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","model"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.health_check","name":"health_check","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","model"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"health_check of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"builtins.bool"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"image_classification":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5],"arg_names":["self","image","model","function_to_apply","top_k"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.image_classification","name":"image_classification","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5],"arg_names":["self","image","model","function_to_apply","top_k"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._common.ContentT"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.image_classification.ImageClassificationOutputTransform"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"image_classification of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"Instance","args":["huggingface_hub.inference._generated.types.image_classification.ImageClassificationOutputElement"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"image_segmentation":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5],"arg_names":["self","image","model","mask_threshold","overlap_mask_area_threshold","subtask","threshold"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.image_segmentation","name":"image_segmentation","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5],"arg_names":["self","image","model","mask_threshold","overlap_mask_area_threshold","subtask","threshold"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._common.ContentT"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationSubtask"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"image_segmentation of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"Instance","args":["huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationOutputElement"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"image_to_image":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,5,5,5,5,5,4],"arg_names":["self","image","prompt","negative_prompt","num_inference_steps","guidance_scale","model","target_size","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.image_to_image","name":"image_to_image","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,5,5,5,5,5,4],"arg_names":["self","image","prompt","negative_prompt","num_inference_steps","guidance_scale","model","target_size","kwargs"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._common.ContentT"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.image_to_image.ImageToImageTargetSize",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"image_to_image of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"PIL.Image.Image"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"image_to_text":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5],"arg_names":["self","image","model"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.image_to_text","name":"image_to_text","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["self","image","model"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._common.ContentT"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"image_to_text of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"huggingface_hub.inference._generated.types.image_to_text.ImageToTextOutput"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"image_to_video":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5,5,5,5,4],"arg_names":["self","image","model","prompt","negative_prompt","num_frames","num_inference_steps","guidance_scale","seed","target_size","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.image_to_video","name":"image_to_video","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,4],"arg_names":["self","image","model","prompt","negative_prompt","num_frames","num_inference_steps","guidance_scale","seed","target_size","kwargs"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._common.ContentT"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.image_to_video.ImageToVideoTargetSize",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"image_to_video of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"model":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.model","name":"model","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"object_detection":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5],"arg_names":["self","image","model","threshold"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.object_detection","name":"object_detection","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5],"arg_names":["self","image","model","threshold"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._common.ContentT"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"object_detection of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"Instance","args":["huggingface_hub.inference._generated.types.object_detection.ObjectDetectionOutputElement"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"provider":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.provider","name":"provider","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._providers.PROVIDER_OR_POLICY_T"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"question_answering":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5,5,5,5,5,5,5,5],"arg_names":["self","question","context","model","align_to_words","doc_stride","handle_impossible_answer","max_answer_len","max_question_len","max_seq_len","top_k"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.question_answering","name":"question_answering","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,5,5,5,5,5,5,5,5],"arg_names":["self","question","context","model","align_to_words","doc_stride","handle_impossible_answer","max_answer_len","max_question_len","max_seq_len","top_k"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","builtins.str","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"question_answering of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringOutputElement",{".class":"Instance","args":["huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringOutputElement"],"extra_attrs":null,"type_ref":"builtins.list"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"sentence_similarity":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5],"arg_names":["self","sentence","other_sentences","model"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.sentence_similarity","name":"sentence_similarity","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,5],"arg_names":["self","sentence","other_sentences","model"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sentence_similarity of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"summarization":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5],"arg_names":["self","text","model","clean_up_tokenization_spaces","generate_parameters","truncation"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.summarization","name":"summarization","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5],"arg_names":["self","text","model","clean_up_tokenization_spaces","generate_parameters","truncation"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.summarization.SummarizationTruncationStrategy"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"summarization of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"huggingface_hub.inference._generated.types.summarization.SummarizationOutput"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"table_question_answering":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5,5,5,5],"arg_names":["self","table","query","model","padding","sequential","truncation"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.table_question_answering","name":"table_question_answering","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,5,5,5,5],"arg_names":["self","table","query","model","padding","sequential","truncation"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.table_question_answering.Padding"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"table_question_answering of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringOutputElement"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"tabular_classification":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5],"arg_names":["self","table","model"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.tabular_classification","name":"tabular_classification","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["self","table","model"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tabular_classification of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"tabular_regression":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5],"arg_names":["self","table","model"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.tabular_regression","name":"tabular_regression","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["self","table","model"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tabular_regression of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"text_classification":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5],"arg_names":["self","text","model","top_k","function_to_apply"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.text_classification","name":"text_classification","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5],"arg_names":["self","text","model","top_k","function_to_apply"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.text_classification.TextClassificationOutputTransform"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_classification of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"Instance","args":["huggingface_hub.inference._generated.types.text_classification.TextClassificationOutputElement"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"text_generation":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.text_generation","impl":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_coroutine","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.text_generation","name":"text_generation","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","builtins.str",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_generation of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"UnionType","items":["builtins.str","huggingface_hub.inference._generated.types.text_generation.TextGenerationOutput",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.AsyncIterable"},{".class":"Instance","args":["huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutput"],"extra_attrs":null,"type_ref":"typing.AsyncIterable"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,3,3,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_coroutine","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.text_generation","name":"text_generation","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,3,3,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","builtins.str",{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_generation of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"Instance","args":["huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutput"],"extra_attrs":null,"type_ref":"typing.AsyncIterable"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.text_generation","name":"text_generation","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,3,3,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","builtins.str",{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_generation of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"Instance","args":["huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutput"],"extra_attrs":null,"type_ref":"typing.AsyncIterable"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,3,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_coroutine","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.text_generation","name":"text_generation","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,3,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","builtins.str",{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_generation of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutput"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.text_generation","name":"text_generation","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,3,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","builtins.str",{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_generation of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutput"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,3,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_coroutine","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.text_generation","name":"text_generation","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,3,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","builtins.str",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_generation of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.AsyncIterable"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.text_generation","name":"text_generation","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5,3,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","builtins.str",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_generation of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.AsyncIterable"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_coroutine","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.text_generation","name":"text_generation","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","builtins.str",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_generation of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"builtins.str"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.text_generation","name":"text_generation","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","builtins.str",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_generation of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"builtins.str"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_coroutine","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.text_generation","name":"text_generation","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","builtins.str",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_generation of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"UnionType","items":["builtins.str","huggingface_hub.inference._generated.types.text_generation.TextGenerationOutput",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.AsyncIterable"},{".class":"Instance","args":["huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutput"],"extra_attrs":null,"type_ref":"typing.AsyncIterable"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.text_generation","name":"text_generation","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","builtins.str",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_generation of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"UnionType","items":["builtins.str","huggingface_hub.inference._generated.types.text_generation.TextGenerationOutput",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.AsyncIterable"},{".class":"Instance","args":["huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutput"],"extra_attrs":null,"type_ref":"typing.AsyncIterable"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,3,3,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","builtins.str",{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_generation of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"Instance","args":["huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutput"],"extra_attrs":null,"type_ref":"typing.AsyncIterable"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,3,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","builtins.str",{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_generation of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutput"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,5,3,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","builtins.str",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_generation of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.AsyncIterable"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","builtins.str",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_generation of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"builtins.str"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","details","stream","model","adapter_id","best_of","decoder_input_details","do_sample","frequency_penalty","grammar","max_new_tokens","repetition_penalty","return_full_text","seed","stop","stop_sequences","temperature","top_k","top_n_tokens","top_p","truncate","typical_p","watermark"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","builtins.str",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_generation of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"UnionType","items":["builtins.str","huggingface_hub.inference._generated.types.text_generation.TextGenerationOutput",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.AsyncIterable"},{".class":"Instance","args":["huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutput"],"extra_attrs":null,"type_ref":"typing.AsyncIterable"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"text_to_image":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","negative_prompt","height","width","num_inference_steps","guidance_scale","model","scheduler","seed","extra_body"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.text_to_image","name":"text_to_image","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5],"arg_names":["self","prompt","negative_prompt","height","width","num_inference_steps","guidance_scale","model","scheduler","seed","extra_body"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_to_image of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"PIL.Image.Image"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"text_to_speech":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","text","model","do_sample","early_stopping","epsilon_cutoff","eta_cutoff","max_length","max_new_tokens","min_length","min_new_tokens","num_beam_groups","num_beams","penalty_alpha","temperature","top_k","top_p","typical_p","use_cache","extra_body"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.text_to_speech","name":"text_to_speech","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],"arg_names":["self","text","model","do_sample","early_stopping","epsilon_cutoff","eta_cutoff","max_length","max_new_tokens","min_length","min_new_tokens","num_beam_groups","num_beams","penalty_alpha","temperature","top_k","top_p","typical_p","use_cache","extra_body"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechEarlyStoppingEnum"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_to_speech of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"text_to_video":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5,5,5],"arg_names":["self","prompt","model","guidance_scale","negative_prompt","num_frames","num_inference_steps","seed","extra_body"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.text_to_video","name":"text_to_video","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5],"arg_names":["self","prompt","model","guidance_scale","negative_prompt","num_frames","num_inference_steps","seed","extra_body"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_to_video of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"timeout":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.timeout","name":"timeout","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"token":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.token","name":"token","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"token_classification":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5],"arg_names":["self","text","model","aggregation_strategy","ignore_labels","stride"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.token_classification","name":"token_classification","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5],"arg_names":["self","text","model","aggregation_strategy","ignore_labels","stride"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.token_classification.TokenClassificationAggregationStrategy"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"token_classification of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"Instance","args":["huggingface_hub.inference._generated.types.token_classification.TokenClassificationOutputElement"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"translation":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5,5],"arg_names":["self","text","model","src_lang","tgt_lang","clean_up_tokenization_spaces","truncation","generate_parameters"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.translation","name":"translation","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5],"arg_names":["self","text","model","src_lang","tgt_lang","clean_up_tokenization_spaces","truncation","generate_parameters"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.translation.TranslationTruncationStrategy"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"translation of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"huggingface_hub.inference._generated.types.translation.TranslationOutput"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"visual_question_answering":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5,5],"arg_names":["self","image","question","model","top_k"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.visual_question_answering","name":"visual_question_answering","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,5,5],"arg_names":["self","image","question","model","top_k"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._common.ContentT"},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"visual_question_answering of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"Instance","args":["huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringOutputElement"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"zero_shot_classification":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5,5,5],"arg_names":["self","text","candidate_labels","multi_label","hypothesis_template","model"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.zero_shot_classification","name":"zero_shot_classification","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,5,5,5],"arg_names":["self","text","candidate_labels","multi_label","hypothesis_template","model"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient","builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zero_shot_classification of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"Instance","args":["huggingface_hub.inference._generated.types.zero_shot_classification.ZeroShotClassificationOutputElement"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"zero_shot_image_classification":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5,5,5],"arg_names":["self","image","candidate_labels","model","hypothesis_template","labels"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.zero_shot_image_classification","name":"zero_shot_image_classification","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,5,5,5],"arg_names":["self","image","candidate_labels","model","hypothesis_template","labels"],"arg_types":["huggingface_hub.inference._generated._async_client.AsyncInferenceClient",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._common.ContentT"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zero_shot_image_classification of AsyncInferenceClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"Instance","args":["huggingface_hub.inference._generated.types.zero_shot_image_classification.ZeroShotImageClassificationOutputElement"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"AsyncIterable":{".class":"SymbolTableNode","cross_ref":"typing.AsyncIterable","kind":"Gdef"},"AudioClassificationOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.audio_classification.AudioClassificationOutputElement","kind":"Gdef"},"AudioClassificationOutputTransform":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.audio_classification.AudioClassificationOutputTransform","kind":"Gdef"},"AudioToAudioOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.audio_to_audio.AudioToAudioOutputElement","kind":"Gdef"},"AutomaticSpeechRecognitionOutput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionOutput","kind":"Gdef"},"BadRequestError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.BadRequestError","kind":"Gdef"},"ChatCompletionInputGrammarType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputGrammarType","kind":"Gdef"},"ChatCompletionInputMessage":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage","kind":"Gdef"},"ChatCompletionInputStreamOptions":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputStreamOptions","kind":"Gdef"},"ChatCompletionInputTool":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool","kind":"Gdef"},"ChatCompletionInputToolChoiceClass":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceClass","kind":"Gdef"},"ChatCompletionInputToolChoiceEnum":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceEnum","kind":"Gdef"},"ChatCompletionOutput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutput","kind":"Gdef"},"ChatCompletionStreamOutput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutput","kind":"Gdef"},"ContentT":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common.ContentT","kind":"Gdef"},"DocumentQuestionAnsweringOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringOutputElement","kind":"Gdef"},"FillMaskOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.fill_mask.FillMaskOutputElement","kind":"Gdef"},"HfHubHTTPError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.HfHubHTTPError","kind":"Gdef"},"Image":{".class":"SymbolTableNode","cross_ref":"PIL.Image.Image","kind":"Gdef"},"ImageClassificationOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.image_classification.ImageClassificationOutputElement","kind":"Gdef"},"ImageClassificationOutputTransform":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.image_classification.ImageClassificationOutputTransform","kind":"Gdef"},"ImageSegmentationOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationOutputElement","kind":"Gdef"},"ImageSegmentationSubtask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationSubtask","kind":"Gdef"},"ImageToImageTargetSize":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.image_to_image.ImageToImageTargetSize","kind":"Gdef"},"ImageToTextOutput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextOutput","kind":"Gdef"},"ImageToVideoTargetSize":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.image_to_video.ImageToVideoTargetSize","kind":"Gdef"},"InferenceTimeoutError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.InferenceTimeoutError","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"MODEL_KWARGS_NOT_USED_REGEX":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.inference._generated._async_client.MODEL_KWARGS_NOT_USED_REGEX","name":"MODEL_KWARGS_NOT_USED_REGEX","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"ObjectDetectionOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.object_detection.ObjectDetectionOutputElement","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"PROVIDER_OR_POLICY_T":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.PROVIDER_OR_POLICY_T","kind":"Gdef"},"Padding":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.table_question_answering.Padding","kind":"Gdef"},"ProxyClientChat":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated._async_client._ProxyClient"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated._async_client.ProxyClientChat","name":"ProxyClientChat","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated._async_client.ProxyClientChat","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._generated._async_client","mro":["huggingface_hub.inference._generated._async_client.ProxyClientChat","huggingface_hub.inference._generated._async_client._ProxyClient","builtins.object"],"names":{".class":"SymbolTable","completions":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client.ProxyClientChat.completions","name":"completions","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.inference._generated._async_client.ProxyClientChat"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"completions of ProxyClientChat","ret_type":"huggingface_hub.inference._generated._async_client.ProxyClientChatCompletions","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"huggingface_hub.inference._generated._async_client.ProxyClientChat.completions","name":"completions","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.inference._generated._async_client.ProxyClientChat"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"completions of ProxyClientChat","ret_type":"huggingface_hub.inference._generated._async_client.ProxyClientChatCompletions","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated._async_client.ProxyClientChat.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated._async_client.ProxyClientChat","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ProxyClientChatCompletions":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated._async_client._ProxyClient"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated._async_client.ProxyClientChatCompletions","name":"ProxyClientChatCompletions","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated._async_client.ProxyClientChatCompletions","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._generated._async_client","mro":["huggingface_hub.inference._generated._async_client.ProxyClientChatCompletions","huggingface_hub.inference._generated._async_client._ProxyClient","builtins.object"],"names":{".class":"SymbolTable","create":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated"],"fullname":"huggingface_hub.inference._generated._async_client.ProxyClientChatCompletions.create","name":"create","original_first_arg":"self","type":null},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"huggingface_hub.inference._generated._async_client.ProxyClientChatCompletions.create","name":"create","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.inference._generated._async_client.ProxyClientChatCompletions"],"fallback":"builtins.function","from_concatenate":false,"implicit":true,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"create of ProxyClientChatCompletions","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated._async_client.ProxyClientChatCompletions.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated._async_client.ProxyClientChatCompletions","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"QuestionAnsweringOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringOutputElement","kind":"Gdef"},"RequestParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common.RequestParameters","kind":"Gdef"},"SummarizationOutput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.summarization.SummarizationOutput","kind":"Gdef"},"SummarizationTruncationStrategy":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.summarization.SummarizationTruncationStrategy","kind":"Gdef"},"TASKS_EXPECTING_IMAGES":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common.TASKS_EXPECTING_IMAGES","kind":"Gdef"},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"TableQuestionAnsweringOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringOutputElement","kind":"Gdef"},"TextClassificationOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_classification.TextClassificationOutputElement","kind":"Gdef"},"TextClassificationOutputTransform":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_classification.TextClassificationOutputTransform","kind":"Gdef"},"TextGenerationInputGrammarType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType","kind":"Gdef"},"TextGenerationOutput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutput","kind":"Gdef"},"TextGenerationStreamOutput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutput","kind":"Gdef"},"TextToSpeechEarlyStoppingEnum":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechEarlyStoppingEnum","kind":"Gdef"},"TokenClassificationAggregationStrategy":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.token_classification.TokenClassificationAggregationStrategy","kind":"Gdef"},"TokenClassificationOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.token_classification.TokenClassificationOutputElement","kind":"Gdef"},"TranslationOutput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.translation.TranslationOutput","kind":"Gdef"},"TranslationTruncationStrategy":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.translation.TranslationTruncationStrategy","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"VisualQuestionAnsweringOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringOutputElement","kind":"Gdef"},"ZeroShotClassificationOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.zero_shot_classification.ZeroShotClassificationOutputElement","kind":"Gdef"},"ZeroShotImageClassificationOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.zero_shot_image_classification.ZeroShotImageClassificationOutputElement","kind":"Gdef"},"_ProxyClient":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated._async_client._ProxyClient","name":"_ProxyClient","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated._async_client._ProxyClient","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._generated._async_client","mro":["huggingface_hub.inference._generated._async_client._ProxyClient","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","client"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._generated._async_client._ProxyClient.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","client"],"arg_types":["huggingface_hub.inference._generated._async_client._ProxyClient","huggingface_hub.inference._generated._async_client.AsyncInferenceClient"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of _ProxyClient","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_client":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._generated._async_client._ProxyClient._client","name":"_client","setter_type":null,"type":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated._async_client._ProxyClient.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated._async_client._ProxyClient","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated._async_client.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated._async_client.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated._async_client.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated._async_client.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated._async_client.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated._async_client.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_async_stream_chat_completion_response":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._async_stream_chat_completion_response","kind":"Gdef"},"_async_stream_text_generation_response":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._async_stream_text_generation_response","kind":"Gdef"},"_async_yield_from":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._async_yield_from","kind":"Gdef"},"_b64_encode":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._b64_encode","kind":"Gdef"},"_b64_to_image":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._b64_to_image","kind":"Gdef"},"_bytes_to_dict":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._bytes_to_dict","kind":"Gdef"},"_bytes_to_image":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._bytes_to_image","kind":"Gdef"},"_bytes_to_list":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._bytes_to_list","kind":"Gdef"},"_get_unsupported_text_generation_kwargs":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._get_unsupported_text_generation_kwargs","kind":"Gdef"},"_import_numpy":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._import_numpy","kind":"Gdef"},"_set_unsupported_text_generation_kwargs":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._set_unsupported_text_generation_kwargs","kind":"Gdef"},"asyncio":{".class":"SymbolTableNode","cross_ref":"asyncio","kind":"Gdef"},"base64":{".class":"SymbolTableNode","cross_ref":"base64","kind":"Gdef"},"build_hf_headers":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._headers.build_hf_headers","kind":"Gdef"},"constants":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.constants","kind":"Gdef"},"get_async_session":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._http.get_async_session","kind":"Gdef"},"get_provider_helper":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.get_provider_helper","kind":"Gdef"},"get_token":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._auth.get_token","kind":"Gdef"},"hf_raise_for_status":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._http.hf_raise_for_status","kind":"Gdef"},"httpx":{".class":"SymbolTableNode","cross_ref":"httpx","kind":"Gdef"},"logger":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.inference._generated._async_client.logger","name":"logger","setter_type":null,"type":"logging.Logger"}},"logging":{".class":"SymbolTableNode","cross_ref":"logging","kind":"Gdef"},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef"},"os":{".class":"SymbolTableNode","cross_ref":"os","kind":"Gdef"},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef"},"raise_text_generation_error":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common.raise_text_generation_error","kind":"Gdef"},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef"},"validate_hf_hub_args":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._validators.validate_hf_hub_args","kind":"Gdef"},"warnings":{".class":"SymbolTableNode","cross_ref":"warnings","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/_async_client.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/_async_client.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/_async_client.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..9173e9dbc9365b850f5a84427acea5d78ac0ce12 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/_async_client.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[50,34,92,99,32,33,93,106,21,22,23,24,25,26,27,28,30,32,105,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],"dep_prios":[5,5,5,5,10,5,5,25,10,10,10,10,10,10,5,5,10,20,25,5,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30],"dependencies":["huggingface_hub.inference._generated.types","huggingface_hub.inference._common","huggingface_hub.inference._providers","huggingface_hub.utils._auth","huggingface_hub.constants","huggingface_hub.errors","huggingface_hub.utils","PIL.Image","asyncio","base64","logging","os","re","warnings","contextlib","typing","httpx","huggingface_hub","numpy","builtins","PIL","_frozen_importlib","_warnings","abc","enum","httpx._client","huggingface_hub.inference._generated.types.audio_classification","huggingface_hub.inference._generated.types.audio_to_audio","huggingface_hub.inference._generated.types.automatic_speech_recognition","huggingface_hub.inference._generated.types.base","huggingface_hub.inference._generated.types.chat_completion","huggingface_hub.inference._generated.types.document_question_answering","huggingface_hub.inference._generated.types.fill_mask","huggingface_hub.inference._generated.types.image_classification","huggingface_hub.inference._generated.types.image_segmentation","huggingface_hub.inference._generated.types.image_to_image","huggingface_hub.inference._generated.types.image_to_text","huggingface_hub.inference._generated.types.image_to_video","huggingface_hub.inference._generated.types.object_detection","huggingface_hub.inference._generated.types.question_answering","huggingface_hub.inference._generated.types.summarization","huggingface_hub.inference._generated.types.table_question_answering","huggingface_hub.inference._generated.types.text_classification","huggingface_hub.inference._generated.types.text_generation","huggingface_hub.inference._generated.types.token_classification","huggingface_hub.inference._generated.types.translation","huggingface_hub.inference._generated.types.visual_question_answering","huggingface_hub.inference._generated.types.zero_shot_classification","huggingface_hub.inference._generated.types.zero_shot_image_classification","huggingface_hub.utils._validators","pathlib"],"hash":"d99b298d4535e73c0b773e140ac4c3e79e11a053","id":"huggingface_hub.inference._generated._async_client","ignore_all":true,"interface_hash":"a26b1de7383bc1322f0f73f70e8607134e63a4ab","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/_async_client.py","plugin_data":null,"size":161289,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..2baa3b66eb075688d1cefef7392acdf7dc123fcb --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._generated.types","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","AudioClassificationInput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.audio_classification.AudioClassificationInput","kind":"Gdef"},"AudioClassificationOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.audio_classification.AudioClassificationOutputElement","kind":"Gdef"},"AudioClassificationOutputTransform":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.audio_classification.AudioClassificationOutputTransform","kind":"Gdef"},"AudioClassificationParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.audio_classification.AudioClassificationParameters","kind":"Gdef"},"AudioToAudioInput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.audio_to_audio.AudioToAudioInput","kind":"Gdef"},"AudioToAudioOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.audio_to_audio.AudioToAudioOutputElement","kind":"Gdef"},"AutomaticSpeechRecognitionEarlyStoppingEnum":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionEarlyStoppingEnum","kind":"Gdef"},"AutomaticSpeechRecognitionGenerationParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionGenerationParameters","kind":"Gdef"},"AutomaticSpeechRecognitionInput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionInput","kind":"Gdef"},"AutomaticSpeechRecognitionOutput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionOutput","kind":"Gdef"},"AutomaticSpeechRecognitionOutputChunk":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionOutputChunk","kind":"Gdef"},"AutomaticSpeechRecognitionParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionParameters","kind":"Gdef"},"BaseInferenceType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.BaseInferenceType","kind":"Gdef"},"ChatCompletionInput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInput","kind":"Gdef"},"ChatCompletionInputFunctionDefinition":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputFunctionDefinition","kind":"Gdef"},"ChatCompletionInputFunctionName":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputFunctionName","kind":"Gdef"},"ChatCompletionInputGrammarType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputGrammarType","kind":"Gdef"},"ChatCompletionInputJSONSchema":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputJSONSchema","kind":"Gdef"},"ChatCompletionInputMessage":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage","kind":"Gdef"},"ChatCompletionInputMessageChunk":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessageChunk","kind":"Gdef"},"ChatCompletionInputMessageChunkType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessageChunkType","kind":"Gdef"},"ChatCompletionInputResponseFormatJSONObject":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputResponseFormatJSONObject","kind":"Gdef"},"ChatCompletionInputResponseFormatJSONSchema":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputResponseFormatJSONSchema","kind":"Gdef"},"ChatCompletionInputResponseFormatText":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputResponseFormatText","kind":"Gdef"},"ChatCompletionInputStreamOptions":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputStreamOptions","kind":"Gdef"},"ChatCompletionInputTool":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool","kind":"Gdef"},"ChatCompletionInputToolCall":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolCall","kind":"Gdef"},"ChatCompletionInputToolChoiceClass":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceClass","kind":"Gdef"},"ChatCompletionInputToolChoiceEnum":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceEnum","kind":"Gdef"},"ChatCompletionInputURL":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputURL","kind":"Gdef"},"ChatCompletionOutput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutput","kind":"Gdef"},"ChatCompletionOutputComplete":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputComplete","kind":"Gdef"},"ChatCompletionOutputFunctionDefinition":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputFunctionDefinition","kind":"Gdef"},"ChatCompletionOutputLogprob":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputLogprob","kind":"Gdef"},"ChatCompletionOutputLogprobs":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputLogprobs","kind":"Gdef"},"ChatCompletionOutputMessage":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputMessage","kind":"Gdef"},"ChatCompletionOutputToolCall":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputToolCall","kind":"Gdef"},"ChatCompletionOutputTopLogprob":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputTopLogprob","kind":"Gdef"},"ChatCompletionOutputUsage":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputUsage","kind":"Gdef"},"ChatCompletionStreamOutput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutput","kind":"Gdef"},"ChatCompletionStreamOutputChoice":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputChoice","kind":"Gdef"},"ChatCompletionStreamOutputDelta":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputDelta","kind":"Gdef"},"ChatCompletionStreamOutputDeltaToolCall":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputDeltaToolCall","kind":"Gdef"},"ChatCompletionStreamOutputFunction":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputFunction","kind":"Gdef"},"ChatCompletionStreamOutputLogprob":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputLogprob","kind":"Gdef"},"ChatCompletionStreamOutputLogprobs":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputLogprobs","kind":"Gdef"},"ChatCompletionStreamOutputTopLogprob":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputTopLogprob","kind":"Gdef"},"ChatCompletionStreamOutputUsage":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputUsage","kind":"Gdef"},"DepthEstimationInput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.depth_estimation.DepthEstimationInput","kind":"Gdef"},"DepthEstimationOutput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.depth_estimation.DepthEstimationOutput","kind":"Gdef"},"DocumentQuestionAnsweringInput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringInput","kind":"Gdef"},"DocumentQuestionAnsweringInputData":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringInputData","kind":"Gdef"},"DocumentQuestionAnsweringOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringOutputElement","kind":"Gdef"},"DocumentQuestionAnsweringParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringParameters","kind":"Gdef"},"FeatureExtractionInput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.feature_extraction.FeatureExtractionInput","kind":"Gdef"},"FeatureExtractionInputTruncationDirection":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.feature_extraction.FeatureExtractionInputTruncationDirection","kind":"Gdef"},"FillMaskInput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.fill_mask.FillMaskInput","kind":"Gdef"},"FillMaskOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.fill_mask.FillMaskOutputElement","kind":"Gdef"},"FillMaskParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.fill_mask.FillMaskParameters","kind":"Gdef"},"ImageClassificationInput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.image_classification.ImageClassificationInput","kind":"Gdef"},"ImageClassificationOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.image_classification.ImageClassificationOutputElement","kind":"Gdef"},"ImageClassificationOutputTransform":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.image_classification.ImageClassificationOutputTransform","kind":"Gdef"},"ImageClassificationParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.image_classification.ImageClassificationParameters","kind":"Gdef"},"ImageSegmentationInput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationInput","kind":"Gdef"},"ImageSegmentationOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationOutputElement","kind":"Gdef"},"ImageSegmentationParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationParameters","kind":"Gdef"},"ImageSegmentationSubtask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationSubtask","kind":"Gdef"},"ImageToImageInput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.image_to_image.ImageToImageInput","kind":"Gdef"},"ImageToImageOutput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.image_to_image.ImageToImageOutput","kind":"Gdef"},"ImageToImageParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.image_to_image.ImageToImageParameters","kind":"Gdef"},"ImageToImageTargetSize":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.image_to_image.ImageToImageTargetSize","kind":"Gdef"},"ImageToTextEarlyStoppingEnum":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextEarlyStoppingEnum","kind":"Gdef"},"ImageToTextGenerationParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextGenerationParameters","kind":"Gdef"},"ImageToTextInput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextInput","kind":"Gdef"},"ImageToTextOutput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextOutput","kind":"Gdef"},"ImageToTextParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextParameters","kind":"Gdef"},"ImageToVideoInput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.image_to_video.ImageToVideoInput","kind":"Gdef"},"ImageToVideoOutput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.image_to_video.ImageToVideoOutput","kind":"Gdef"},"ImageToVideoParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.image_to_video.ImageToVideoParameters","kind":"Gdef"},"ImageToVideoTargetSize":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.image_to_video.ImageToVideoTargetSize","kind":"Gdef"},"ObjectDetectionBoundingBox":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.object_detection.ObjectDetectionBoundingBox","kind":"Gdef"},"ObjectDetectionInput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.object_detection.ObjectDetectionInput","kind":"Gdef"},"ObjectDetectionOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.object_detection.ObjectDetectionOutputElement","kind":"Gdef"},"ObjectDetectionParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.object_detection.ObjectDetectionParameters","kind":"Gdef"},"Padding":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.table_question_answering.Padding","kind":"Gdef"},"QuestionAnsweringInput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringInput","kind":"Gdef"},"QuestionAnsweringInputData":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringInputData","kind":"Gdef"},"QuestionAnsweringOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringOutputElement","kind":"Gdef"},"QuestionAnsweringParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringParameters","kind":"Gdef"},"SentenceSimilarityInput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.sentence_similarity.SentenceSimilarityInput","kind":"Gdef"},"SentenceSimilarityInputData":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.sentence_similarity.SentenceSimilarityInputData","kind":"Gdef"},"SummarizationInput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.summarization.SummarizationInput","kind":"Gdef"},"SummarizationOutput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.summarization.SummarizationOutput","kind":"Gdef"},"SummarizationParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.summarization.SummarizationParameters","kind":"Gdef"},"SummarizationTruncationStrategy":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.summarization.SummarizationTruncationStrategy","kind":"Gdef"},"TableQuestionAnsweringInput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringInput","kind":"Gdef"},"TableQuestionAnsweringInputData":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringInputData","kind":"Gdef"},"TableQuestionAnsweringOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringOutputElement","kind":"Gdef"},"TableQuestionAnsweringParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringParameters","kind":"Gdef"},"Text2TextGenerationInput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text2text_generation.Text2TextGenerationInput","kind":"Gdef"},"Text2TextGenerationOutput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text2text_generation.Text2TextGenerationOutput","kind":"Gdef"},"Text2TextGenerationParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text2text_generation.Text2TextGenerationParameters","kind":"Gdef"},"Text2TextGenerationTruncationStrategy":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text2text_generation.Text2TextGenerationTruncationStrategy","kind":"Gdef"},"TextClassificationInput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_classification.TextClassificationInput","kind":"Gdef"},"TextClassificationOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_classification.TextClassificationOutputElement","kind":"Gdef"},"TextClassificationOutputTransform":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_classification.TextClassificationOutputTransform","kind":"Gdef"},"TextClassificationParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_classification.TextClassificationParameters","kind":"Gdef"},"TextGenerationInput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInput","kind":"Gdef"},"TextGenerationInputGenerateParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGenerateParameters","kind":"Gdef"},"TextGenerationInputGrammarType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType","kind":"Gdef"},"TextGenerationOutput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutput","kind":"Gdef"},"TextGenerationOutputBestOfSequence":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputBestOfSequence","kind":"Gdef"},"TextGenerationOutputDetails":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputDetails","kind":"Gdef"},"TextGenerationOutputFinishReason":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputFinishReason","kind":"Gdef"},"TextGenerationOutputPrefillToken":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputPrefillToken","kind":"Gdef"},"TextGenerationOutputToken":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputToken","kind":"Gdef"},"TextGenerationStreamOutput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutput","kind":"Gdef"},"TextGenerationStreamOutputStreamDetails":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutputStreamDetails","kind":"Gdef"},"TextGenerationStreamOutputToken":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutputToken","kind":"Gdef"},"TextToAudioEarlyStoppingEnum":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioEarlyStoppingEnum","kind":"Gdef"},"TextToAudioGenerationParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioGenerationParameters","kind":"Gdef"},"TextToAudioInput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioInput","kind":"Gdef"},"TextToAudioOutput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioOutput","kind":"Gdef"},"TextToAudioParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioParameters","kind":"Gdef"},"TextToImageInput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_to_image.TextToImageInput","kind":"Gdef"},"TextToImageOutput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_to_image.TextToImageOutput","kind":"Gdef"},"TextToImageParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_to_image.TextToImageParameters","kind":"Gdef"},"TextToSpeechEarlyStoppingEnum":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechEarlyStoppingEnum","kind":"Gdef"},"TextToSpeechGenerationParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechGenerationParameters","kind":"Gdef"},"TextToSpeechInput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechInput","kind":"Gdef"},"TextToSpeechOutput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechOutput","kind":"Gdef"},"TextToSpeechParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechParameters","kind":"Gdef"},"TextToVideoInput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_to_video.TextToVideoInput","kind":"Gdef"},"TextToVideoOutput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_to_video.TextToVideoOutput","kind":"Gdef"},"TextToVideoParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_to_video.TextToVideoParameters","kind":"Gdef"},"TokenClassificationAggregationStrategy":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.token_classification.TokenClassificationAggregationStrategy","kind":"Gdef"},"TokenClassificationInput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.token_classification.TokenClassificationInput","kind":"Gdef"},"TokenClassificationOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.token_classification.TokenClassificationOutputElement","kind":"Gdef"},"TokenClassificationParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.token_classification.TokenClassificationParameters","kind":"Gdef"},"TranslationInput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.translation.TranslationInput","kind":"Gdef"},"TranslationOutput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.translation.TranslationOutput","kind":"Gdef"},"TranslationParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.translation.TranslationParameters","kind":"Gdef"},"TranslationTruncationStrategy":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.translation.TranslationTruncationStrategy","kind":"Gdef"},"TypeEnum":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.text_generation.TypeEnum","kind":"Gdef"},"VideoClassificationInput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.video_classification.VideoClassificationInput","kind":"Gdef"},"VideoClassificationOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.video_classification.VideoClassificationOutputElement","kind":"Gdef"},"VideoClassificationOutputTransform":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.video_classification.VideoClassificationOutputTransform","kind":"Gdef"},"VideoClassificationParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.video_classification.VideoClassificationParameters","kind":"Gdef"},"VisualQuestionAnsweringInput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringInput","kind":"Gdef"},"VisualQuestionAnsweringInputData":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringInputData","kind":"Gdef"},"VisualQuestionAnsweringOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringOutputElement","kind":"Gdef"},"VisualQuestionAnsweringParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringParameters","kind":"Gdef"},"ZeroShotClassificationInput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.zero_shot_classification.ZeroShotClassificationInput","kind":"Gdef"},"ZeroShotClassificationOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.zero_shot_classification.ZeroShotClassificationOutputElement","kind":"Gdef"},"ZeroShotClassificationParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.zero_shot_classification.ZeroShotClassificationParameters","kind":"Gdef"},"ZeroShotImageClassificationInput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.zero_shot_image_classification.ZeroShotImageClassificationInput","kind":"Gdef"},"ZeroShotImageClassificationOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.zero_shot_image_classification.ZeroShotImageClassificationOutputElement","kind":"Gdef"},"ZeroShotImageClassificationParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.zero_shot_image_classification.ZeroShotImageClassificationParameters","kind":"Gdef"},"ZeroShotObjectDetectionBoundingBox":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.zero_shot_object_detection.ZeroShotObjectDetectionBoundingBox","kind":"Gdef"},"ZeroShotObjectDetectionInput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.zero_shot_object_detection.ZeroShotObjectDetectionInput","kind":"Gdef"},"ZeroShotObjectDetectionOutputElement":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.zero_shot_object_detection.ZeroShotObjectDetectionOutputElement","kind":"Gdef"},"ZeroShotObjectDetectionParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.zero_shot_object_detection.ZeroShotObjectDetectionParameters","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/__init__.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..f6a23562883278e1aff147cec4cc3c182ed8a4f4 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[6,12,13,21,22,59,60,66,67,68,74,80,81,88,89,95,101,102,108,115,121,127,142,149,150,157,158,164,165,171,177,182,187,1,1,1,1],"dep_prios":[5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,30,30,30],"dependencies":["huggingface_hub.inference._generated.types.audio_classification","huggingface_hub.inference._generated.types.audio_to_audio","huggingface_hub.inference._generated.types.automatic_speech_recognition","huggingface_hub.inference._generated.types.base","huggingface_hub.inference._generated.types.chat_completion","huggingface_hub.inference._generated.types.depth_estimation","huggingface_hub.inference._generated.types.document_question_answering","huggingface_hub.inference._generated.types.feature_extraction","huggingface_hub.inference._generated.types.fill_mask","huggingface_hub.inference._generated.types.image_classification","huggingface_hub.inference._generated.types.image_segmentation","huggingface_hub.inference._generated.types.image_to_image","huggingface_hub.inference._generated.types.image_to_text","huggingface_hub.inference._generated.types.image_to_video","huggingface_hub.inference._generated.types.object_detection","huggingface_hub.inference._generated.types.question_answering","huggingface_hub.inference._generated.types.sentence_similarity","huggingface_hub.inference._generated.types.summarization","huggingface_hub.inference._generated.types.table_question_answering","huggingface_hub.inference._generated.types.text2text_generation","huggingface_hub.inference._generated.types.text_classification","huggingface_hub.inference._generated.types.text_generation","huggingface_hub.inference._generated.types.text_to_audio","huggingface_hub.inference._generated.types.text_to_image","huggingface_hub.inference._generated.types.text_to_speech","huggingface_hub.inference._generated.types.text_to_video","huggingface_hub.inference._generated.types.token_classification","huggingface_hub.inference._generated.types.translation","huggingface_hub.inference._generated.types.video_classification","huggingface_hub.inference._generated.types.visual_question_answering","huggingface_hub.inference._generated.types.zero_shot_classification","huggingface_hub.inference._generated.types.zero_shot_image_classification","huggingface_hub.inference._generated.types.zero_shot_object_detection","builtins","_frozen_importlib","abc","typing"],"hash":"4fbd1232f616a4a1ba05aabbdc31dfe47357749d","id":"huggingface_hub.inference._generated.types","ignore_all":true,"interface_hash":"2901c4fe55b034ffda824d503ed1c3c60234381e","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/__init__.py","plugin_data":null,"size":6557,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/audio_classification.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/audio_classification.data.json new file mode 100644 index 0000000000000000000000000000000000000000..86d6a4618e571326a794cf3f69970b8615311914 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/audio_classification.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._generated.types.audio_classification","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","AudioClassificationInput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.audio_classification.AudioClassificationInput","name":"AudioClassificationInput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.audio_classification.AudioClassificationInput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.audio_classification","mro":["huggingface_hub.inference._generated.types.audio_classification.AudioClassificationInput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","inputs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.audio_classification.AudioClassificationInput.inputs","name":"inputs","setter_type":null,"type":"builtins.str"}},"parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.audio_classification.AudioClassificationInput.parameters","name":"parameters","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.audio_classification.AudioClassificationParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.audio_classification.AudioClassificationInput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.audio_classification.AudioClassificationInput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"AudioClassificationOutputElement":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.audio_classification.AudioClassificationOutputElement","name":"AudioClassificationOutputElement","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.audio_classification.AudioClassificationOutputElement","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.audio_classification","mro":["huggingface_hub.inference._generated.types.audio_classification.AudioClassificationOutputElement","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","label":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.audio_classification.AudioClassificationOutputElement.label","name":"label","setter_type":null,"type":"builtins.str"}},"score":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.audio_classification.AudioClassificationOutputElement.score","name":"score","setter_type":null,"type":"builtins.float"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.audio_classification.AudioClassificationOutputElement.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.audio_classification.AudioClassificationOutputElement","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"AudioClassificationOutputTransform":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.inference._generated.types.audio_classification.AudioClassificationOutputTransform","line":11,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"sigmoid"},{".class":"LiteralType","fallback":"builtins.str","value":"softmax"},{".class":"LiteralType","fallback":"builtins.str","value":"none"}],"uses_pep604_syntax":false}}},"AudioClassificationParameters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.audio_classification.AudioClassificationParameters","name":"AudioClassificationParameters","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.audio_classification.AudioClassificationParameters","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.audio_classification","mro":["huggingface_hub.inference._generated.types.audio_classification.AudioClassificationParameters","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","function_to_apply":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.audio_classification.AudioClassificationParameters.function_to_apply","name":"function_to_apply","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.audio_classification.AudioClassificationOutputTransform"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"top_k":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.audio_classification.AudioClassificationParameters.top_k","name":"top_k","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.audio_classification.AudioClassificationParameters.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.audio_classification.AudioClassificationParameters","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"BaseInferenceType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.BaseInferenceType","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.audio_classification.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.audio_classification.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.audio_classification.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.audio_classification.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.audio_classification.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.audio_classification.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"dataclass_with_extra":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.dataclass_with_extra","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/audio_classification.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/audio_classification.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/audio_classification.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..fdfc81a8e3a76de2abf4db6adf03a9616fc5ee60 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/audio_classification.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[8,6,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["huggingface_hub.inference._generated.types.base","typing","builtins","_frozen_importlib","_typeshed","abc"],"hash":"53ac6e015cacd06ad86764086d3a13df4562cd33","id":"huggingface_hub.inference._generated.types.audio_classification","ignore_all":true,"interface_hash":"2174523531c9ca35e54052c524601e53bd455cf0","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/audio_classification.py","plugin_data":null,"size":1573,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/audio_to_audio.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/audio_to_audio.data.json new file mode 100644 index 0000000000000000000000000000000000000000..d619c7f1be9a35d6c66463af6673c0097f33d4e5 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/audio_to_audio.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._generated.types.audio_to_audio","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"AudioToAudioInput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.audio_to_audio.AudioToAudioInput","name":"AudioToAudioInput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.audio_to_audio.AudioToAudioInput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.audio_to_audio","mro":["huggingface_hub.inference._generated.types.audio_to_audio.AudioToAudioInput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","inputs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.audio_to_audio.AudioToAudioInput.inputs","name":"inputs","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.audio_to_audio.AudioToAudioInput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.audio_to_audio.AudioToAudioInput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"AudioToAudioOutputElement":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.audio_to_audio.AudioToAudioOutputElement","name":"AudioToAudioOutputElement","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.audio_to_audio.AudioToAudioOutputElement","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.audio_to_audio","mro":["huggingface_hub.inference._generated.types.audio_to_audio.AudioToAudioOutputElement","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","blob":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.audio_to_audio.AudioToAudioOutputElement.blob","name":"blob","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"content_type":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.audio_to_audio.AudioToAudioOutputElement.content_type","name":"content_type","setter_type":null,"type":"builtins.str"}},"label":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.audio_to_audio.AudioToAudioOutputElement.label","name":"label","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.audio_to_audio.AudioToAudioOutputElement.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.audio_to_audio.AudioToAudioOutputElement","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"BaseInferenceType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.BaseInferenceType","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.audio_to_audio.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.audio_to_audio.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.audio_to_audio.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.audio_to_audio.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.audio_to_audio.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.audio_to_audio.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"dataclass_with_extra":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.dataclass_with_extra","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/audio_to_audio.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/audio_to_audio.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/audio_to_audio.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..70f885477711db6b24abdc883f98e913bde22fff --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/audio_to_audio.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[8,6,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["huggingface_hub.inference._generated.types.base","typing","builtins","_frozen_importlib","_typeshed","abc"],"hash":"50339ceadb13168dfec86e62220b17319fb520b6","id":"huggingface_hub.inference._generated.types.audio_to_audio","ignore_all":true,"interface_hash":"ba9b41246d7cb38efcd268956723b34c3555c75d","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/audio_to_audio.py","plugin_data":null,"size":891,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/automatic_speech_recognition.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/automatic_speech_recognition.data.json new file mode 100644 index 0000000000000000000000000000000000000000..c565800441ac90be4085e64ca46e9265344828b9 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/automatic_speech_recognition.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","AutomaticSpeechRecognitionEarlyStoppingEnum":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionEarlyStoppingEnum","line":11,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"LiteralType","fallback":"builtins.str","value":"never"}}},"AutomaticSpeechRecognitionGenerationParameters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionGenerationParameters","name":"AutomaticSpeechRecognitionGenerationParameters","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionGenerationParameters","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.automatic_speech_recognition","mro":["huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionGenerationParameters","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","do_sample":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionGenerationParameters.do_sample","name":"do_sample","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"early_stopping":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionGenerationParameters.early_stopping","name":"early_stopping","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionEarlyStoppingEnum"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"epsilon_cutoff":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionGenerationParameters.epsilon_cutoff","name":"epsilon_cutoff","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"eta_cutoff":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionGenerationParameters.eta_cutoff","name":"eta_cutoff","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"max_length":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionGenerationParameters.max_length","name":"max_length","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"max_new_tokens":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionGenerationParameters.max_new_tokens","name":"max_new_tokens","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"min_length":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionGenerationParameters.min_length","name":"min_length","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"min_new_tokens":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionGenerationParameters.min_new_tokens","name":"min_new_tokens","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"num_beam_groups":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionGenerationParameters.num_beam_groups","name":"num_beam_groups","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"num_beams":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionGenerationParameters.num_beams","name":"num_beams","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"penalty_alpha":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionGenerationParameters.penalty_alpha","name":"penalty_alpha","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"temperature":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionGenerationParameters.temperature","name":"temperature","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"top_k":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionGenerationParameters.top_k","name":"top_k","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"top_p":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionGenerationParameters.top_p","name":"top_p","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"typical_p":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionGenerationParameters.typical_p","name":"typical_p","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"use_cache":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionGenerationParameters.use_cache","name":"use_cache","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionGenerationParameters.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionGenerationParameters","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"AutomaticSpeechRecognitionInput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionInput","name":"AutomaticSpeechRecognitionInput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionInput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.automatic_speech_recognition","mro":["huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionInput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","inputs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionInput.inputs","name":"inputs","setter_type":null,"type":"builtins.str"}},"parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionInput.parameters","name":"parameters","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionInput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionInput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"AutomaticSpeechRecognitionOutput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionOutput","name":"AutomaticSpeechRecognitionOutput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionOutput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.automatic_speech_recognition","mro":["huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionOutput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","chunks":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionOutput.chunks","name":"chunks","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionOutputChunk"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"text":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionOutput.text","name":"text","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionOutput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionOutput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"AutomaticSpeechRecognitionOutputChunk":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionOutputChunk","name":"AutomaticSpeechRecognitionOutputChunk","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionOutputChunk","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.automatic_speech_recognition","mro":["huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionOutputChunk","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","text":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionOutputChunk.text","name":"text","setter_type":null,"type":"builtins.str"}},"timestamp":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionOutputChunk.timestamp","name":"timestamp","setter_type":null,"type":{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"builtins.list"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionOutputChunk.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionOutputChunk","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"AutomaticSpeechRecognitionParameters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionParameters","name":"AutomaticSpeechRecognitionParameters","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionParameters","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.automatic_speech_recognition","mro":["huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionParameters","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","generation_parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionParameters.generation_parameters","name":"generation_parameters","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionGenerationParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"return_timestamps":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionParameters.return_timestamps","name":"return_timestamps","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionParameters.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.automatic_speech_recognition.AutomaticSpeechRecognitionParameters","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"BaseInferenceType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.BaseInferenceType","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.automatic_speech_recognition.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"dataclass_with_extra":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.dataclass_with_extra","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/automatic_speech_recognition.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/automatic_speech_recognition.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/automatic_speech_recognition.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..bf761ccda1bce36808d2e5da99e09426e8857053 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/automatic_speech_recognition.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[8,6,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["huggingface_hub.inference._generated.types.base","typing","builtins","_frozen_importlib","_typeshed","abc"],"hash":"2e79b1f9e8e27803e7cff5b3721131e812823c16","id":"huggingface_hub.inference._generated.types.automatic_speech_recognition","ignore_all":true,"interface_hash":"23f6336f0c7ff26b5f19d239eb4fd3bea4f1a2bc","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/automatic_speech_recognition.py","plugin_data":null,"size":5509,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/base.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/base.data.json new file mode 100644 index 0000000000000000000000000000000000000000..36a24329193907262c9763f5e544fe1710d5c0ce --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/base.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._generated.types.base","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseInferenceType":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.base.BaseInferenceType","name":"BaseInferenceType","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.base.BaseInferenceType","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{"dataclass":{"attributes":[],"frozen":false},"dataclass_tag":{}},"module_name":"huggingface_hub.inference._generated.types.base","mro":["huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"huggingface_hub.inference._generated.types.base.BaseInferenceType.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"dataclasses.Field"}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__mypy-post_init":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.base.BaseInferenceType.__mypy-post_init","name":"__mypy-post_init","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-post_init of BaseInferenceType","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"huggingface_hub.inference._generated.types.base.BaseInferenceType.__mypy-replace","name":"__mypy-replace","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of BaseInferenceType","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"huggingface_hub.inference._generated.types.base.BaseInferenceType.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of BaseInferenceType","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"__post_init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.base.BaseInferenceType.__post_init__","name":"__post_init__","original_first_arg":"self","type":null}},"__setattr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self",null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._generated.types.base.BaseInferenceType.__setattr__","name":"__setattr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self",null,null],"arg_types":["huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__setattr__ of BaseInferenceType","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__setitem__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":[null,null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._generated.types.base.BaseInferenceType.__setitem__","name":"__setitem__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,null,null],"arg_types":["huggingface_hub.inference._generated.types.base.BaseInferenceType",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__setitem__ of BaseInferenceType","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"parse_obj":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","data"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated"],"fullname":"huggingface_hub.inference._generated.types.base.BaseInferenceType.parse_obj","name":"parse_obj","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","data"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.base.T","id":-1,"name":"T","namespace":"huggingface_hub.inference._generated.types.base.BaseInferenceType.parse_obj","upper_bound":"huggingface_hub.inference._generated.types.base.BaseInferenceType","values":[],"variance":0}},{".class":"UnionType","items":["builtins.bytes","builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parse_obj of BaseInferenceType","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.base.T","id":-1,"name":"T","namespace":"huggingface_hub.inference._generated.types.base.BaseInferenceType.parse_obj","upper_bound":"huggingface_hub.inference._generated.types.base.BaseInferenceType","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.base.T","id":-1,"name":"T","namespace":"huggingface_hub.inference._generated.types.base.BaseInferenceType.parse_obj","upper_bound":"huggingface_hub.inference._generated.types.base.BaseInferenceType","values":[],"variance":0}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.base.T","id":-1,"name":"T","namespace":"huggingface_hub.inference._generated.types.base.BaseInferenceType.parse_obj","upper_bound":"huggingface_hub.inference._generated.types.base.BaseInferenceType","values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"huggingface_hub.inference._generated.types.base.BaseInferenceType.parse_obj","name":"parse_obj","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","data"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.base.T","id":-1,"name":"T","namespace":"huggingface_hub.inference._generated.types.base.BaseInferenceType.parse_obj","upper_bound":"huggingface_hub.inference._generated.types.base.BaseInferenceType","values":[],"variance":0}},{".class":"UnionType","items":["builtins.bytes","builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parse_obj of BaseInferenceType","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.base.T","id":-1,"name":"T","namespace":"huggingface_hub.inference._generated.types.base.BaseInferenceType.parse_obj","upper_bound":"huggingface_hub.inference._generated.types.base.BaseInferenceType","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.base.T","id":-1,"name":"T","namespace":"huggingface_hub.inference._generated.types.base.BaseInferenceType.parse_obj","upper_bound":"huggingface_hub.inference._generated.types.base.BaseInferenceType","values":[],"variance":0}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.base.T","id":-1,"name":"T","namespace":"huggingface_hub.inference._generated.types.base.BaseInferenceType.parse_obj","upper_bound":"huggingface_hub.inference._generated.types.base.BaseInferenceType","values":[],"variance":0}]}}}},"parse_obj_as_instance":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","data"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated"],"fullname":"huggingface_hub.inference._generated.types.base.BaseInferenceType.parse_obj_as_instance","name":"parse_obj_as_instance","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","data"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.base.T","id":-1,"name":"T","namespace":"huggingface_hub.inference._generated.types.base.BaseInferenceType.parse_obj_as_instance","upper_bound":"huggingface_hub.inference._generated.types.base.BaseInferenceType","values":[],"variance":0}},{".class":"UnionType","items":["builtins.bytes","builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parse_obj_as_instance of BaseInferenceType","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.base.T","id":-1,"name":"T","namespace":"huggingface_hub.inference._generated.types.base.BaseInferenceType.parse_obj_as_instance","upper_bound":"huggingface_hub.inference._generated.types.base.BaseInferenceType","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.base.T","id":-1,"name":"T","namespace":"huggingface_hub.inference._generated.types.base.BaseInferenceType.parse_obj_as_instance","upper_bound":"huggingface_hub.inference._generated.types.base.BaseInferenceType","values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"huggingface_hub.inference._generated.types.base.BaseInferenceType.parse_obj_as_instance","name":"parse_obj_as_instance","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","data"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.base.T","id":-1,"name":"T","namespace":"huggingface_hub.inference._generated.types.base.BaseInferenceType.parse_obj_as_instance","upper_bound":"huggingface_hub.inference._generated.types.base.BaseInferenceType","values":[],"variance":0}},{".class":"UnionType","items":["builtins.bytes","builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parse_obj_as_instance of BaseInferenceType","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.base.T","id":-1,"name":"T","namespace":"huggingface_hub.inference._generated.types.base.BaseInferenceType.parse_obj_as_instance","upper_bound":"huggingface_hub.inference._generated.types.base.BaseInferenceType","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.base.T","id":-1,"name":"T","namespace":"huggingface_hub.inference._generated.types.base.BaseInferenceType.parse_obj_as_instance","upper_bound":"huggingface_hub.inference._generated.types.base.BaseInferenceType","values":[],"variance":0}]}}}},"parse_obj_as_list":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","data"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated"],"fullname":"huggingface_hub.inference._generated.types.base.BaseInferenceType.parse_obj_as_list","name":"parse_obj_as_list","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","data"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.base.T","id":-1,"name":"T","namespace":"huggingface_hub.inference._generated.types.base.BaseInferenceType.parse_obj_as_list","upper_bound":"huggingface_hub.inference._generated.types.base.BaseInferenceType","values":[],"variance":0}},{".class":"UnionType","items":["builtins.bytes","builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parse_obj_as_list of BaseInferenceType","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.base.T","id":-1,"name":"T","namespace":"huggingface_hub.inference._generated.types.base.BaseInferenceType.parse_obj_as_list","upper_bound":"huggingface_hub.inference._generated.types.base.BaseInferenceType","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.base.T","id":-1,"name":"T","namespace":"huggingface_hub.inference._generated.types.base.BaseInferenceType.parse_obj_as_list","upper_bound":"huggingface_hub.inference._generated.types.base.BaseInferenceType","values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"huggingface_hub.inference._generated.types.base.BaseInferenceType.parse_obj_as_list","name":"parse_obj_as_list","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","data"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.base.T","id":-1,"name":"T","namespace":"huggingface_hub.inference._generated.types.base.BaseInferenceType.parse_obj_as_list","upper_bound":"huggingface_hub.inference._generated.types.base.BaseInferenceType","values":[],"variance":0}},{".class":"UnionType","items":["builtins.bytes","builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parse_obj_as_list of BaseInferenceType","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.base.T","id":-1,"name":"T","namespace":"huggingface_hub.inference._generated.types.base.BaseInferenceType.parse_obj_as_list","upper_bound":"huggingface_hub.inference._generated.types.base.BaseInferenceType","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.base.T","id":-1,"name":"T","namespace":"huggingface_hub.inference._generated.types.base.BaseInferenceType.parse_obj_as_list","upper_bound":"huggingface_hub.inference._generated.types.base.BaseInferenceType","values":[],"variance":0}]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.base.BaseInferenceType.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.base.BaseInferenceType","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"T":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.base.T","name":"T","upper_bound":"huggingface_hub.inference._generated.types.base.BaseInferenceType","values":[],"variance":0}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.base.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.base.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.base.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.base.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.base.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.base.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_repr_with_extra":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.base._repr_with_extra","name":"_repr_with_extra","original_first_arg":"self","type":null}},"asdict":{".class":"SymbolTableNode","cross_ref":"dataclasses.asdict","kind":"Gdef"},"dataclass":{".class":"SymbolTableNode","cross_ref":"dataclasses.dataclass","kind":"Gdef"},"dataclass_with_extra":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.base.dataclass_with_extra","name":"dataclass_with_extra","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.base.T","id":-1,"name":"T","namespace":"huggingface_hub.inference._generated.types.base.dataclass_with_extra","upper_bound":"huggingface_hub.inference._generated.types.base.BaseInferenceType","values":[],"variance":0}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dataclass_with_extra","ret_type":{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.base.T","id":-1,"name":"T","namespace":"huggingface_hub.inference._generated.types.base.dataclass_with_extra","upper_bound":"huggingface_hub.inference._generated.types.base.BaseInferenceType","values":[],"variance":0}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.base.T","id":-1,"name":"T","namespace":"huggingface_hub.inference._generated.types.base.dataclass_with_extra","upper_bound":"huggingface_hub.inference._generated.types.base.BaseInferenceType","values":[],"variance":0}]}}},"get_args":{".class":"SymbolTableNode","cross_ref":"typing.get_args","kind":"Gdef"},"inspect":{".class":"SymbolTableNode","cross_ref":"inspect","kind":"Gdef"},"json":{".class":"SymbolTableNode","cross_ref":"json","kind":"Gdef"},"normalize_key":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["key"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.base.normalize_key","name":"normalize_key","original_first_arg":"key","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["key"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"normalize_key","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"types":{".class":"SymbolTableNode","cross_ref":"types","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/base.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/base.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/base.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..e4b85f8b73057fc7eea32091984805e088778f3c --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/base.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[16,17,18,19,20,1,1,1,1],"dep_prios":[10,10,10,5,5,5,30,30,30],"dependencies":["inspect","json","types","dataclasses","typing","builtins","_frozen_importlib","_typeshed","abc"],"hash":"bc45c9167dc41bb3d68a8f80ce4a99ba3c9a10a2","id":"huggingface_hub.inference._generated.types.base","ignore_all":true,"interface_hash":"7a603a7eb1815517b6de1c79d87613ef29ff8313","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/base.py","plugin_data":null,"size":6896,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/chat_completion.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/chat_completion.data.json new file mode 100644 index 0000000000000000000000000000000000000000..3423fec6da370c056c92ade0d054560f56dfddc7 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/chat_completion.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._generated.types.chat_completion","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseInferenceType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.BaseInferenceType","kind":"Gdef"},"ChatCompletionInput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInput","name":"ChatCompletionInput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.chat_completion","mro":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","frequency_penalty":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInput.frequency_penalty","name":"frequency_penalty","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"logit_bias":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInput.logit_bias","name":"logit_bias","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"logprobs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInput.logprobs","name":"logprobs","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"max_tokens":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInput.max_tokens","name":"max_tokens","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"messages":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInput.messages","name":"messages","setter_type":null,"type":{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage"],"extra_attrs":null,"type_ref":"builtins.list"}}},"model":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInput.model","name":"model","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"n":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInput.n","name":"n","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"presence_penalty":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInput.presence_penalty","name":"presence_penalty","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"response_format":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInput.response_format","name":"response_format","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputGrammarType"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"seed":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInput.seed","name":"seed","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"stop":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInput.stop","name":"stop","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"stream":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInput.stream","name":"stream","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"stream_options":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInput.stream_options","name":"stream_options","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputStreamOptions",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"temperature":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInput.temperature","name":"temperature","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"tool_choice":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInput.tool_choice","name":"tool_choice","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceClass",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceEnum"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"tool_prompt":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInput.tool_prompt","name":"tool_prompt","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"tools":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInput.tools","name":"tools","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"top_logprobs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInput.top_logprobs","name":"top_logprobs","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"top_p":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInput.top_p","name":"top_p","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ChatCompletionInputFunctionDefinition":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputFunctionDefinition","name":"ChatCompletionInputFunctionDefinition","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputFunctionDefinition","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.chat_completion","mro":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputFunctionDefinition","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","description":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputFunctionDefinition.description","name":"description","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"name":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputFunctionDefinition.name","name":"name","setter_type":null,"type":"builtins.str"}},"parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputFunctionDefinition.parameters","name":"parameters","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputFunctionDefinition.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputFunctionDefinition","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ChatCompletionInputFunctionName":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputFunctionName","name":"ChatCompletionInputFunctionName","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputFunctionName","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.chat_completion","mro":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputFunctionName","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","name":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputFunctionName.name","name":"name","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputFunctionName.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputFunctionName","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ChatCompletionInputGrammarType":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputGrammarType","line":88,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputResponseFormatText","huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputResponseFormatJSONSchema","huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputResponseFormatJSONObject"],"uses_pep604_syntax":false}}},"ChatCompletionInputJSONSchema":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputJSONSchema","name":"ChatCompletionInputJSONSchema","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputJSONSchema","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.chat_completion","mro":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputJSONSchema","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","description":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputJSONSchema.description","name":"description","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"name":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputJSONSchema.name","name":"name","setter_type":null,"type":"builtins.str"}},"schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputJSONSchema.schema","name":"schema","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","builtins.object"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"strict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputJSONSchema.strict","name":"strict","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputJSONSchema.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputJSONSchema","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ChatCompletionInputMessage":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage","name":"ChatCompletionInputMessage","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.chat_completion","mro":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","content":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage.content","name":"content","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessageChunk"],"extra_attrs":null,"type_ref":"builtins.list"},"builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"name":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage.name","name":"name","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"role":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage.role","name":"role","setter_type":null,"type":"builtins.str"}},"tool_calls":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage.tool_calls","name":"tool_calls","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolCall"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ChatCompletionInputMessageChunk":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessageChunk","name":"ChatCompletionInputMessageChunk","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessageChunk","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.chat_completion","mro":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessageChunk","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","image_url":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessageChunk.image_url","name":"image_url","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputURL",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"text":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessageChunk.text","name":"text","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"type":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessageChunk.type","name":"type","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessageChunkType"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessageChunk.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessageChunk","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ChatCompletionInputMessageChunkType":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessageChunkType","line":16,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"text"},{".class":"LiteralType","fallback":"builtins.str","value":"image_url"}],"uses_pep604_syntax":false}}},"ChatCompletionInputResponseFormatJSONObject":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputResponseFormatJSONObject","name":"ChatCompletionInputResponseFormatJSONObject","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputResponseFormatJSONObject","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.chat_completion","mro":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputResponseFormatJSONObject","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","type":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputResponseFormatJSONObject.type","name":"type","setter_type":null,"type":{".class":"LiteralType","fallback":"builtins.str","value":"json_object"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputResponseFormatJSONObject.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputResponseFormatJSONObject","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ChatCompletionInputResponseFormatJSONSchema":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputResponseFormatJSONSchema","name":"ChatCompletionInputResponseFormatJSONSchema","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputResponseFormatJSONSchema","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.chat_completion","mro":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputResponseFormatJSONSchema","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","json_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputResponseFormatJSONSchema.json_schema","name":"json_schema","setter_type":null,"type":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputJSONSchema"}},"type":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputResponseFormatJSONSchema.type","name":"type","setter_type":null,"type":{".class":"LiteralType","fallback":"builtins.str","value":"json_schema"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputResponseFormatJSONSchema.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputResponseFormatJSONSchema","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ChatCompletionInputResponseFormatText":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputResponseFormatText","name":"ChatCompletionInputResponseFormatText","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputResponseFormatText","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.chat_completion","mro":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputResponseFormatText","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","type":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputResponseFormatText.type","name":"type","setter_type":null,"type":{".class":"LiteralType","fallback":"builtins.str","value":"text"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputResponseFormatText.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputResponseFormatText","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ChatCompletionInputStreamOptions":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputStreamOptions","name":"ChatCompletionInputStreamOptions","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputStreamOptions","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.chat_completion","mro":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputStreamOptions","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","include_usage":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputStreamOptions.include_usage","name":"include_usage","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputStreamOptions.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputStreamOptions","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ChatCompletionInputTool":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool","name":"ChatCompletionInputTool","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.chat_completion","mro":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","function":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool.function","name":"function","setter_type":null,"type":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputFunctionDefinition"}},"type":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool.type","name":"type","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ChatCompletionInputToolCall":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolCall","name":"ChatCompletionInputToolCall","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolCall","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.chat_completion","mro":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolCall","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","function":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolCall.function","name":"function","setter_type":null,"type":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputFunctionDefinition"}},"id":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolCall.id","name":"id","setter_type":null,"type":"builtins.str"}},"type":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolCall.type","name":"type","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolCall.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolCall","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ChatCompletionInputToolChoiceClass":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceClass","name":"ChatCompletionInputToolChoiceClass","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceClass","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.chat_completion","mro":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceClass","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","function":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceClass.function","name":"function","setter_type":null,"type":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputFunctionName"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceClass.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceClass","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ChatCompletionInputToolChoiceEnum":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceEnum","line":115,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"auto"},{".class":"LiteralType","fallback":"builtins.str","value":"none"},{".class":"LiteralType","fallback":"builtins.str","value":"required"}],"uses_pep604_syntax":false}}},"ChatCompletionInputURL":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputURL","name":"ChatCompletionInputURL","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputURL","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.chat_completion","mro":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputURL","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","url":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputURL.url","name":"url","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputURL.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputURL","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ChatCompletionOutput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutput","name":"ChatCompletionOutput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.chat_completion","mro":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","choices":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutput.choices","name":"choices","setter_type":null,"type":{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputComplete"],"extra_attrs":null,"type_ref":"builtins.list"}}},"created":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutput.created","name":"created","setter_type":null,"type":"builtins.int"}},"id":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutput.id","name":"id","setter_type":null,"type":"builtins.str"}},"model":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutput.model","name":"model","setter_type":null,"type":"builtins.str"}},"system_fingerprint":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutput.system_fingerprint","name":"system_fingerprint","setter_type":null,"type":"builtins.str"}},"usage":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutput.usage","name":"usage","setter_type":null,"type":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputUsage"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ChatCompletionOutputComplete":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputComplete","name":"ChatCompletionOutputComplete","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputComplete","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.chat_completion","mro":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputComplete","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","finish_reason":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputComplete.finish_reason","name":"finish_reason","setter_type":null,"type":"builtins.str"}},"index":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputComplete.index","name":"index","setter_type":null,"type":"builtins.int"}},"logprobs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputComplete.logprobs","name":"logprobs","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputLogprobs",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"message":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputComplete.message","name":"message","setter_type":null,"type":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputMessage"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputComplete.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputComplete","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ChatCompletionOutputFunctionDefinition":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputFunctionDefinition","name":"ChatCompletionOutputFunctionDefinition","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputFunctionDefinition","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.chat_completion","mro":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputFunctionDefinition","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","arguments":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputFunctionDefinition.arguments","name":"arguments","setter_type":null,"type":"builtins.str"}},"description":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputFunctionDefinition.description","name":"description","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"name":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputFunctionDefinition.name","name":"name","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputFunctionDefinition.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputFunctionDefinition","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ChatCompletionOutputLogprob":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputLogprob","name":"ChatCompletionOutputLogprob","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputLogprob","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.chat_completion","mro":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputLogprob","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","logprob":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputLogprob.logprob","name":"logprob","setter_type":null,"type":"builtins.float"}},"token":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputLogprob.token","name":"token","setter_type":null,"type":"builtins.str"}},"top_logprobs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputLogprob.top_logprobs","name":"top_logprobs","setter_type":null,"type":{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputTopLogprob"],"extra_attrs":null,"type_ref":"builtins.list"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputLogprob.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputLogprob","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ChatCompletionOutputLogprobs":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputLogprobs","name":"ChatCompletionOutputLogprobs","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputLogprobs","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.chat_completion","mro":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputLogprobs","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","content":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputLogprobs.content","name":"content","setter_type":null,"type":{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputLogprob"],"extra_attrs":null,"type_ref":"builtins.list"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputLogprobs.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputLogprobs","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ChatCompletionOutputMessage":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputMessage","name":"ChatCompletionOutputMessage","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputMessage","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.chat_completion","mro":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputMessage","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","content":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputMessage.content","name":"content","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"reasoning":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputMessage.reasoning","name":"reasoning","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"role":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputMessage.role","name":"role","setter_type":null,"type":"builtins.str"}},"tool_call_id":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputMessage.tool_call_id","name":"tool_call_id","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"tool_calls":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputMessage.tool_calls","name":"tool_calls","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputToolCall"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputMessage.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputMessage","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ChatCompletionOutputToolCall":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputToolCall","name":"ChatCompletionOutputToolCall","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputToolCall","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.chat_completion","mro":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputToolCall","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","function":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputToolCall.function","name":"function","setter_type":null,"type":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputFunctionDefinition"}},"id":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputToolCall.id","name":"id","setter_type":null,"type":"builtins.str"}},"type":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputToolCall.type","name":"type","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputToolCall.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputToolCall","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ChatCompletionOutputTopLogprob":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputTopLogprob","name":"ChatCompletionOutputTopLogprob","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputTopLogprob","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.chat_completion","mro":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputTopLogprob","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","logprob":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputTopLogprob.logprob","name":"logprob","setter_type":null,"type":"builtins.float"}},"token":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputTopLogprob.token","name":"token","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputTopLogprob.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputTopLogprob","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ChatCompletionOutputUsage":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputUsage","name":"ChatCompletionOutputUsage","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputUsage","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.chat_completion","mro":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputUsage","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","completion_tokens":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputUsage.completion_tokens","name":"completion_tokens","setter_type":null,"type":"builtins.int"}},"prompt_tokens":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputUsage.prompt_tokens","name":"prompt_tokens","setter_type":null,"type":"builtins.int"}},"total_tokens":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputUsage.total_tokens","name":"total_tokens","setter_type":null,"type":"builtins.int"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputUsage.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionOutputUsage","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ChatCompletionStreamOutput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutput","name":"ChatCompletionStreamOutput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.chat_completion","mro":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","choices":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutput.choices","name":"choices","setter_type":null,"type":{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputChoice"],"extra_attrs":null,"type_ref":"builtins.list"}}},"created":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutput.created","name":"created","setter_type":null,"type":"builtins.int"}},"id":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutput.id","name":"id","setter_type":null,"type":"builtins.str"}},"model":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutput.model","name":"model","setter_type":null,"type":"builtins.str"}},"system_fingerprint":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutput.system_fingerprint","name":"system_fingerprint","setter_type":null,"type":"builtins.str"}},"usage":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutput.usage","name":"usage","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputUsage",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ChatCompletionStreamOutputChoice":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputChoice","name":"ChatCompletionStreamOutputChoice","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputChoice","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.chat_completion","mro":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputChoice","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","delta":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputChoice.delta","name":"delta","setter_type":null,"type":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputDelta"}},"finish_reason":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputChoice.finish_reason","name":"finish_reason","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"index":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputChoice.index","name":"index","setter_type":null,"type":"builtins.int"}},"logprobs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputChoice.logprobs","name":"logprobs","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputLogprobs",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputChoice.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputChoice","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ChatCompletionStreamOutputDelta":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputDelta","name":"ChatCompletionStreamOutputDelta","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputDelta","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.chat_completion","mro":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputDelta","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","content":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputDelta.content","name":"content","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"reasoning":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputDelta.reasoning","name":"reasoning","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"role":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputDelta.role","name":"role","setter_type":null,"type":"builtins.str"}},"tool_call_id":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputDelta.tool_call_id","name":"tool_call_id","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"tool_calls":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputDelta.tool_calls","name":"tool_calls","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputDeltaToolCall"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputDelta.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputDelta","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ChatCompletionStreamOutputDeltaToolCall":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputDeltaToolCall","name":"ChatCompletionStreamOutputDeltaToolCall","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputDeltaToolCall","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.chat_completion","mro":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputDeltaToolCall","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","function":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputDeltaToolCall.function","name":"function","setter_type":null,"type":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputFunction"}},"id":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputDeltaToolCall.id","name":"id","setter_type":null,"type":"builtins.str"}},"index":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputDeltaToolCall.index","name":"index","setter_type":null,"type":"builtins.int"}},"type":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputDeltaToolCall.type","name":"type","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputDeltaToolCall.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputDeltaToolCall","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ChatCompletionStreamOutputFunction":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputFunction","name":"ChatCompletionStreamOutputFunction","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputFunction","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.chat_completion","mro":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputFunction","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","arguments":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputFunction.arguments","name":"arguments","setter_type":null,"type":"builtins.str"}},"name":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputFunction.name","name":"name","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputFunction.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputFunction","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ChatCompletionStreamOutputLogprob":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputLogprob","name":"ChatCompletionStreamOutputLogprob","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputLogprob","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.chat_completion","mro":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputLogprob","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","logprob":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputLogprob.logprob","name":"logprob","setter_type":null,"type":"builtins.float"}},"token":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputLogprob.token","name":"token","setter_type":null,"type":"builtins.str"}},"top_logprobs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputLogprob.top_logprobs","name":"top_logprobs","setter_type":null,"type":{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputTopLogprob"],"extra_attrs":null,"type_ref":"builtins.list"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputLogprob.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputLogprob","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ChatCompletionStreamOutputLogprobs":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputLogprobs","name":"ChatCompletionStreamOutputLogprobs","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputLogprobs","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.chat_completion","mro":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputLogprobs","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","content":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputLogprobs.content","name":"content","setter_type":null,"type":{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputLogprob"],"extra_attrs":null,"type_ref":"builtins.list"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputLogprobs.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputLogprobs","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ChatCompletionStreamOutputTopLogprob":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputTopLogprob","name":"ChatCompletionStreamOutputTopLogprob","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputTopLogprob","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.chat_completion","mro":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputTopLogprob","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","logprob":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputTopLogprob.logprob","name":"logprob","setter_type":null,"type":"builtins.float"}},"token":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputTopLogprob.token","name":"token","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputTopLogprob.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputTopLogprob","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ChatCompletionStreamOutputUsage":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputUsage","name":"ChatCompletionStreamOutputUsage","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputUsage","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.chat_completion","mro":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputUsage","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","completion_tokens":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputUsage.completion_tokens","name":"completion_tokens","setter_type":null,"type":"builtins.int"}},"prompt_tokens":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputUsage.prompt_tokens","name":"prompt_tokens","setter_type":null,"type":"builtins.int"}},"total_tokens":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputUsage.total_tokens","name":"total_tokens","setter_type":null,"type":"builtins.int"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputUsage.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputUsage","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.chat_completion.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"dataclass_with_extra":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.dataclass_with_extra","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/chat_completion.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/chat_completion.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/chat_completion.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..7f284eeba3e1c4ee0af4d6c62d00977071199326 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/chat_completion.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[8,6,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["huggingface_hub.inference._generated.types.base","typing","builtins","_frozen_importlib","_typeshed","abc"],"hash":"068fd365cf36ea37e842a342933e847605b36f5b","id":"huggingface_hub.inference._generated.types.chat_completion","ignore_all":true,"interface_hash":"3ce085f622404dced877f619c7ef4cf14876fd78","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/chat_completion.py","plugin_data":null,"size":11242,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/depth_estimation.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/depth_estimation.data.json new file mode 100644 index 0000000000000000000000000000000000000000..2386b407f8ef44fb9c90841a21346ecbabe0f3d6 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/depth_estimation.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._generated.types.depth_estimation","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseInferenceType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.BaseInferenceType","kind":"Gdef"},"DepthEstimationInput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.depth_estimation.DepthEstimationInput","name":"DepthEstimationInput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.depth_estimation.DepthEstimationInput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.depth_estimation","mro":["huggingface_hub.inference._generated.types.depth_estimation.DepthEstimationInput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","inputs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.depth_estimation.DepthEstimationInput.inputs","name":"inputs","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.depth_estimation.DepthEstimationInput.parameters","name":"parameters","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.depth_estimation.DepthEstimationInput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.depth_estimation.DepthEstimationInput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"DepthEstimationOutput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.depth_estimation.DepthEstimationOutput","name":"DepthEstimationOutput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.depth_estimation.DepthEstimationOutput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.depth_estimation","mro":["huggingface_hub.inference._generated.types.depth_estimation.DepthEstimationOutput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","depth":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.depth_estimation.DepthEstimationOutput.depth","name":"depth","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"predicted_depth":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.depth_estimation.DepthEstimationOutput.predicted_depth","name":"predicted_depth","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.depth_estimation.DepthEstimationOutput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.depth_estimation.DepthEstimationOutput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.depth_estimation.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.depth_estimation.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.depth_estimation.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.depth_estimation.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.depth_estimation.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.depth_estimation.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"dataclass_with_extra":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.dataclass_with_extra","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/depth_estimation.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/depth_estimation.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/depth_estimation.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..5d47543f9e25ca81162802c7fca1a332558e74ba --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/depth_estimation.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[8,6,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["huggingface_hub.inference._generated.types.base","typing","builtins","_frozen_importlib","_typeshed","abc"],"hash":"d4f2c0d934d3cdee12d12499183267fbe16ebbe5","id":"huggingface_hub.inference._generated.types.depth_estimation","ignore_all":true,"interface_hash":"cbedab1ea5a3c86460bb6bd0ad025627b6397af2","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/depth_estimation.py","plugin_data":null,"size":923,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/document_question_answering.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/document_question_answering.data.json new file mode 100644 index 0000000000000000000000000000000000000000..35736acecef3f5a04b81fc98882a355a9665676b --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/document_question_answering.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._generated.types.document_question_answering","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseInferenceType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.BaseInferenceType","kind":"Gdef"},"DocumentQuestionAnsweringInput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringInput","name":"DocumentQuestionAnsweringInput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringInput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.document_question_answering","mro":["huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringInput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","inputs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringInput.inputs","name":"inputs","setter_type":null,"type":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringInputData"}},"parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringInput.parameters","name":"parameters","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringInput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringInput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"DocumentQuestionAnsweringInputData":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringInputData","name":"DocumentQuestionAnsweringInputData","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringInputData","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.document_question_answering","mro":["huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringInputData","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","image":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringInputData.image","name":"image","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"question":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringInputData.question","name":"question","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringInputData.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringInputData","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"DocumentQuestionAnsweringOutputElement":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringOutputElement","name":"DocumentQuestionAnsweringOutputElement","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringOutputElement","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.document_question_answering","mro":["huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringOutputElement","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","answer":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringOutputElement.answer","name":"answer","setter_type":null,"type":"builtins.str"}},"end":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringOutputElement.end","name":"end","setter_type":null,"type":"builtins.int"}},"score":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringOutputElement.score","name":"score","setter_type":null,"type":"builtins.float"}},"start":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringOutputElement.start","name":"start","setter_type":null,"type":"builtins.int"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringOutputElement.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringOutputElement","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"DocumentQuestionAnsweringParameters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringParameters","name":"DocumentQuestionAnsweringParameters","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringParameters","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.document_question_answering","mro":["huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringParameters","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","doc_stride":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringParameters.doc_stride","name":"doc_stride","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"handle_impossible_answer":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringParameters.handle_impossible_answer","name":"handle_impossible_answer","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"lang":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringParameters.lang","name":"lang","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"max_answer_len":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringParameters.max_answer_len","name":"max_answer_len","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"max_question_len":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringParameters.max_question_len","name":"max_question_len","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"max_seq_len":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringParameters.max_seq_len","name":"max_seq_len","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"top_k":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringParameters.top_k","name":"top_k","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"word_boxes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringParameters.word_boxes","name":"word_boxes","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"builtins.list"},"builtins.str"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringParameters.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.document_question_answering.DocumentQuestionAnsweringParameters","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.document_question_answering.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.document_question_answering.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.document_question_answering.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.document_question_answering.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.document_question_answering.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.document_question_answering.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"dataclass_with_extra":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.dataclass_with_extra","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/document_question_answering.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/document_question_answering.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/document_question_answering.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..020d0a616863411a5aee9416d865e530bff477f6 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/document_question_answering.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[8,6,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["huggingface_hub.inference._generated.types.base","typing","builtins","_frozen_importlib","_typeshed","abc"],"hash":"8900bf3e526fbe19a9d4b4296216105ac39ec633","id":"huggingface_hub.inference._generated.types.document_question_answering","ignore_all":true,"interface_hash":"81436143307d9dcbb991e55c3fde7446458d634d","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/document_question_answering.py","plugin_data":null,"size":3196,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/feature_extraction.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/feature_extraction.data.json new file mode 100644 index 0000000000000000000000000000000000000000..04c0fbaf1d14676345e6b4234cad1467d299c021 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/feature_extraction.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._generated.types.feature_extraction","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","BaseInferenceType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.BaseInferenceType","kind":"Gdef"},"FeatureExtractionInput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.feature_extraction.FeatureExtractionInput","name":"FeatureExtractionInput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.feature_extraction.FeatureExtractionInput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.feature_extraction","mro":["huggingface_hub.inference._generated.types.feature_extraction.FeatureExtractionInput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","inputs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.feature_extraction.FeatureExtractionInput.inputs","name":"inputs","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},"builtins.str"],"uses_pep604_syntax":false}}},"normalize":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.feature_extraction.FeatureExtractionInput.normalize","name":"normalize","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"prompt_name":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.feature_extraction.FeatureExtractionInput.prompt_name","name":"prompt_name","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"truncate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.feature_extraction.FeatureExtractionInput.truncate","name":"truncate","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"truncation_direction":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.feature_extraction.FeatureExtractionInput.truncation_direction","name":"truncation_direction","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.feature_extraction.FeatureExtractionInputTruncationDirection"},{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.feature_extraction.FeatureExtractionInput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.feature_extraction.FeatureExtractionInput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"FeatureExtractionInputTruncationDirection":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.inference._generated.types.feature_extraction.FeatureExtractionInputTruncationDirection","line":11,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"Left"},{".class":"LiteralType","fallback":"builtins.str","value":"Right"}],"uses_pep604_syntax":false}}},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.feature_extraction.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.feature_extraction.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.feature_extraction.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.feature_extraction.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.feature_extraction.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.feature_extraction.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"dataclass_with_extra":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.dataclass_with_extra","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/feature_extraction.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/feature_extraction.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/feature_extraction.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..4b715ad77aceb9a35e2e6a047f248b83ae2bbef0 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/feature_extraction.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[8,6,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["huggingface_hub.inference._generated.types.base","typing","builtins","_frozen_importlib","_typeshed","abc"],"hash":"76a6c916c06e2283840c075c9b76e9e66ed22546","id":"huggingface_hub.inference._generated.types.feature_extraction","ignore_all":true,"interface_hash":"4388ac8986f7a25615aee6f79d32b0fbbce75643","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/feature_extraction.py","plugin_data":null,"size":1531,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/fill_mask.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/fill_mask.data.json new file mode 100644 index 0000000000000000000000000000000000000000..fd8c1ed81ae492d7739de6990a601a515ec3b133 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/fill_mask.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._generated.types.fill_mask","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseInferenceType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.BaseInferenceType","kind":"Gdef"},"FillMaskInput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.fill_mask.FillMaskInput","name":"FillMaskInput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.fill_mask.FillMaskInput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.fill_mask","mro":["huggingface_hub.inference._generated.types.fill_mask.FillMaskInput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","inputs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.fill_mask.FillMaskInput.inputs","name":"inputs","setter_type":null,"type":"builtins.str"}},"parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.fill_mask.FillMaskInput.parameters","name":"parameters","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.fill_mask.FillMaskParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.fill_mask.FillMaskInput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.fill_mask.FillMaskInput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"FillMaskOutputElement":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.fill_mask.FillMaskOutputElement","name":"FillMaskOutputElement","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.fill_mask.FillMaskOutputElement","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.fill_mask","mro":["huggingface_hub.inference._generated.types.fill_mask.FillMaskOutputElement","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","fill_mask_output_token_str":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.fill_mask.FillMaskOutputElement.fill_mask_output_token_str","name":"fill_mask_output_token_str","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"score":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.fill_mask.FillMaskOutputElement.score","name":"score","setter_type":null,"type":"builtins.float"}},"sequence":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.fill_mask.FillMaskOutputElement.sequence","name":"sequence","setter_type":null,"type":"builtins.str"}},"token":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.fill_mask.FillMaskOutputElement.token","name":"token","setter_type":null,"type":"builtins.int"}},"token_str":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.fill_mask.FillMaskOutputElement.token_str","name":"token_str","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.fill_mask.FillMaskOutputElement.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.fill_mask.FillMaskOutputElement","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"FillMaskParameters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.fill_mask.FillMaskParameters","name":"FillMaskParameters","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.fill_mask.FillMaskParameters","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.fill_mask","mro":["huggingface_hub.inference._generated.types.fill_mask.FillMaskParameters","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","targets":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.fill_mask.FillMaskParameters.targets","name":"targets","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"top_k":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.fill_mask.FillMaskParameters.top_k","name":"top_k","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.fill_mask.FillMaskParameters.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.fill_mask.FillMaskParameters","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.fill_mask.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.fill_mask.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.fill_mask.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.fill_mask.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.fill_mask.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.fill_mask.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"dataclass_with_extra":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.dataclass_with_extra","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/fill_mask.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/fill_mask.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/fill_mask.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..030fe7faf7b5b3229eb9325c0caa117beed6f510 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/fill_mask.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[8,6,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["huggingface_hub.inference._generated.types.base","typing","builtins","_frozen_importlib","_typeshed","abc"],"hash":"8ce0d19ce896ed8f99137dc6ec66082517e88b77","id":"huggingface_hub.inference._generated.types.fill_mask","ignore_all":true,"interface_hash":"e6e0b488d818a3c54c43d950b83ca4c360225480","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/fill_mask.py","plugin_data":null,"size":1702,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/image_classification.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/image_classification.data.json new file mode 100644 index 0000000000000000000000000000000000000000..d7c93aec5d23a6c4a0e2e0d591608f0d2c62ce3c --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/image_classification.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._generated.types.image_classification","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","BaseInferenceType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.BaseInferenceType","kind":"Gdef"},"ImageClassificationInput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.image_classification.ImageClassificationInput","name":"ImageClassificationInput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.image_classification.ImageClassificationInput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.image_classification","mro":["huggingface_hub.inference._generated.types.image_classification.ImageClassificationInput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","inputs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_classification.ImageClassificationInput.inputs","name":"inputs","setter_type":null,"type":"builtins.str"}},"parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_classification.ImageClassificationInput.parameters","name":"parameters","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.image_classification.ImageClassificationParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.image_classification.ImageClassificationInput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.image_classification.ImageClassificationInput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ImageClassificationOutputElement":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.image_classification.ImageClassificationOutputElement","name":"ImageClassificationOutputElement","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.image_classification.ImageClassificationOutputElement","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.image_classification","mro":["huggingface_hub.inference._generated.types.image_classification.ImageClassificationOutputElement","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","label":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_classification.ImageClassificationOutputElement.label","name":"label","setter_type":null,"type":"builtins.str"}},"score":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_classification.ImageClassificationOutputElement.score","name":"score","setter_type":null,"type":"builtins.float"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.image_classification.ImageClassificationOutputElement.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.image_classification.ImageClassificationOutputElement","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ImageClassificationOutputTransform":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.inference._generated.types.image_classification.ImageClassificationOutputTransform","line":11,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"sigmoid"},{".class":"LiteralType","fallback":"builtins.str","value":"softmax"},{".class":"LiteralType","fallback":"builtins.str","value":"none"}],"uses_pep604_syntax":false}}},"ImageClassificationParameters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.image_classification.ImageClassificationParameters","name":"ImageClassificationParameters","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.image_classification.ImageClassificationParameters","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.image_classification","mro":["huggingface_hub.inference._generated.types.image_classification.ImageClassificationParameters","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","function_to_apply":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_classification.ImageClassificationParameters.function_to_apply","name":"function_to_apply","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.image_classification.ImageClassificationOutputTransform"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"top_k":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_classification.ImageClassificationParameters.top_k","name":"top_k","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.image_classification.ImageClassificationParameters.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.image_classification.ImageClassificationParameters","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_classification.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_classification.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_classification.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_classification.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_classification.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_classification.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"dataclass_with_extra":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.dataclass_with_extra","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/image_classification.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/image_classification.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/image_classification.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..3a237314b1253755327b86d370955bd2cfffc144 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/image_classification.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[8,6,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["huggingface_hub.inference._generated.types.base","typing","builtins","_frozen_importlib","_typeshed","abc"],"hash":"d64c0d76d03a9b84c52a3531c047ac3338885041","id":"huggingface_hub.inference._generated.types.image_classification","ignore_all":true,"interface_hash":"5895bc23d79eaa9fd39831573917ddc33d1d0d6b","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/image_classification.py","plugin_data":null,"size":1585,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/image_segmentation.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/image_segmentation.data.json new file mode 100644 index 0000000000000000000000000000000000000000..e4a0714ef919999247f6c81a2bc476e7aa53c98a --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/image_segmentation.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._generated.types.image_segmentation","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","BaseInferenceType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.BaseInferenceType","kind":"Gdef"},"ImageSegmentationInput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationInput","name":"ImageSegmentationInput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationInput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.image_segmentation","mro":["huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationInput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","inputs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationInput.inputs","name":"inputs","setter_type":null,"type":"builtins.str"}},"parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationInput.parameters","name":"parameters","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationInput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationInput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ImageSegmentationOutputElement":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationOutputElement","name":"ImageSegmentationOutputElement","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationOutputElement","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.image_segmentation","mro":["huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationOutputElement","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","label":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationOutputElement.label","name":"label","setter_type":null,"type":"builtins.str"}},"mask":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationOutputElement.mask","name":"mask","setter_type":null,"type":"builtins.str"}},"score":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationOutputElement.score","name":"score","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationOutputElement.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationOutputElement","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ImageSegmentationParameters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationParameters","name":"ImageSegmentationParameters","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationParameters","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.image_segmentation","mro":["huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationParameters","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","mask_threshold":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationParameters.mask_threshold","name":"mask_threshold","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"overlap_mask_area_threshold":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationParameters.overlap_mask_area_threshold","name":"overlap_mask_area_threshold","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"subtask":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationParameters.subtask","name":"subtask","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationSubtask"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"threshold":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationParameters.threshold","name":"threshold","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationParameters.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationParameters","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ImageSegmentationSubtask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.inference._generated.types.image_segmentation.ImageSegmentationSubtask","line":11,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"instance"},{".class":"LiteralType","fallback":"builtins.str","value":"panoptic"},{".class":"LiteralType","fallback":"builtins.str","value":"semantic"}],"uses_pep604_syntax":false}}},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_segmentation.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_segmentation.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_segmentation.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_segmentation.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_segmentation.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_segmentation.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"dataclass_with_extra":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.dataclass_with_extra","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/image_segmentation.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/image_segmentation.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/image_segmentation.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..7744e55dc5dc646102ed1ee6ebaf701c75af6fe9 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/image_segmentation.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[8,6,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["huggingface_hub.inference._generated.types.base","typing","builtins","_frozen_importlib","_typeshed","abc"],"hash":"72588b12699f3dacbc3b543e7c7b452b83700186","id":"huggingface_hub.inference._generated.types.image_segmentation","ignore_all":true,"interface_hash":"5f109033e7c620badd116803f6c7d51959939796","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/image_segmentation.py","plugin_data":null,"size":1950,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/image_to_image.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/image_to_image.data.json new file mode 100644 index 0000000000000000000000000000000000000000..0b6e9dfd0c6e08f6a37513b5e3d41bb1bc7523f6 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/image_to_image.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._generated.types.image_to_image","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseInferenceType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.BaseInferenceType","kind":"Gdef"},"ImageToImageInput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.image_to_image.ImageToImageInput","name":"ImageToImageInput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.image_to_image.ImageToImageInput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.image_to_image","mro":["huggingface_hub.inference._generated.types.image_to_image.ImageToImageInput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","inputs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_to_image.ImageToImageInput.inputs","name":"inputs","setter_type":null,"type":"builtins.str"}},"parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_to_image.ImageToImageInput.parameters","name":"parameters","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.image_to_image.ImageToImageParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.image_to_image.ImageToImageInput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.image_to_image.ImageToImageInput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ImageToImageOutput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.image_to_image.ImageToImageOutput","name":"ImageToImageOutput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.image_to_image.ImageToImageOutput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.image_to_image","mro":["huggingface_hub.inference._generated.types.image_to_image.ImageToImageOutput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","image":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_to_image.ImageToImageOutput.image","name":"image","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.image_to_image.ImageToImageOutput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.image_to_image.ImageToImageOutput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ImageToImageParameters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.image_to_image.ImageToImageParameters","name":"ImageToImageParameters","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.image_to_image.ImageToImageParameters","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.image_to_image","mro":["huggingface_hub.inference._generated.types.image_to_image.ImageToImageParameters","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","guidance_scale":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_to_image.ImageToImageParameters.guidance_scale","name":"guidance_scale","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"negative_prompt":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_to_image.ImageToImageParameters.negative_prompt","name":"negative_prompt","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"num_inference_steps":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_to_image.ImageToImageParameters.num_inference_steps","name":"num_inference_steps","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"prompt":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_to_image.ImageToImageParameters.prompt","name":"prompt","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"target_size":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_to_image.ImageToImageParameters.target_size","name":"target_size","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.image_to_image.ImageToImageTargetSize",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.image_to_image.ImageToImageParameters.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.image_to_image.ImageToImageParameters","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ImageToImageTargetSize":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.image_to_image.ImageToImageTargetSize","name":"ImageToImageTargetSize","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.image_to_image.ImageToImageTargetSize","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.image_to_image","mro":["huggingface_hub.inference._generated.types.image_to_image.ImageToImageTargetSize","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","height":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_to_image.ImageToImageTargetSize.height","name":"height","setter_type":null,"type":"builtins.int"}},"width":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_to_image.ImageToImageTargetSize.width","name":"width","setter_type":null,"type":"builtins.int"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.image_to_image.ImageToImageTargetSize.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.image_to_image.ImageToImageTargetSize","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_to_image.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_to_image.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_to_image.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_to_image.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_to_image.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_to_image.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"dataclass_with_extra":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.dataclass_with_extra","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/image_to_image.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/image_to_image.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/image_to_image.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..8fcbf30a968baa2206fada0b5af5657d2979317d --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/image_to_image.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[8,6,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["huggingface_hub.inference._generated.types.base","typing","builtins","_frozen_importlib","_typeshed","abc"],"hash":"1ae25f9bfcab737e55d8f5c41cb5cac3991a9107","id":"huggingface_hub.inference._generated.types.image_to_image","ignore_all":true,"interface_hash":"fb44398db9337e12991a8085810d2263f4bd6502","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/image_to_image.py","plugin_data":null,"size":2290,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/image_to_text.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/image_to_text.data.json new file mode 100644 index 0000000000000000000000000000000000000000..9a15a78f06a025931a931b09f99934b2ed5fc010 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/image_to_text.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._generated.types.image_to_text","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseInferenceType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.BaseInferenceType","kind":"Gdef"},"ImageToTextEarlyStoppingEnum":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextEarlyStoppingEnum","line":11,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"LiteralType","fallback":"builtins.str","value":"never"}}},"ImageToTextGenerationParameters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextGenerationParameters","name":"ImageToTextGenerationParameters","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextGenerationParameters","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.image_to_text","mro":["huggingface_hub.inference._generated.types.image_to_text.ImageToTextGenerationParameters","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","do_sample":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextGenerationParameters.do_sample","name":"do_sample","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"early_stopping":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextGenerationParameters.early_stopping","name":"early_stopping","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextEarlyStoppingEnum"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"epsilon_cutoff":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextGenerationParameters.epsilon_cutoff","name":"epsilon_cutoff","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"eta_cutoff":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextGenerationParameters.eta_cutoff","name":"eta_cutoff","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"max_length":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextGenerationParameters.max_length","name":"max_length","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"max_new_tokens":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextGenerationParameters.max_new_tokens","name":"max_new_tokens","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"min_length":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextGenerationParameters.min_length","name":"min_length","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"min_new_tokens":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextGenerationParameters.min_new_tokens","name":"min_new_tokens","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"num_beam_groups":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextGenerationParameters.num_beam_groups","name":"num_beam_groups","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"num_beams":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextGenerationParameters.num_beams","name":"num_beams","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"penalty_alpha":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextGenerationParameters.penalty_alpha","name":"penalty_alpha","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"temperature":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextGenerationParameters.temperature","name":"temperature","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"top_k":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextGenerationParameters.top_k","name":"top_k","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"top_p":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextGenerationParameters.top_p","name":"top_p","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"typical_p":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextGenerationParameters.typical_p","name":"typical_p","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"use_cache":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextGenerationParameters.use_cache","name":"use_cache","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextGenerationParameters.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextGenerationParameters","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ImageToTextInput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextInput","name":"ImageToTextInput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextInput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.image_to_text","mro":["huggingface_hub.inference._generated.types.image_to_text.ImageToTextInput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","inputs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextInput.inputs","name":"inputs","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextInput.parameters","name":"parameters","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.image_to_text.ImageToTextParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextInput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextInput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ImageToTextOutput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextOutput","name":"ImageToTextOutput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextOutput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.image_to_text","mro":["huggingface_hub.inference._generated.types.image_to_text.ImageToTextOutput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","generated_text":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextOutput.generated_text","name":"generated_text","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"image_to_text_output_generated_text":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextOutput.image_to_text_output_generated_text","name":"image_to_text_output_generated_text","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextOutput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextOutput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ImageToTextParameters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextParameters","name":"ImageToTextParameters","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextParameters","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.image_to_text","mro":["huggingface_hub.inference._generated.types.image_to_text.ImageToTextParameters","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","generation_parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextParameters.generation_parameters","name":"generation_parameters","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.image_to_text.ImageToTextGenerationParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"max_new_tokens":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextParameters.max_new_tokens","name":"max_new_tokens","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextParameters.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.image_to_text.ImageToTextParameters","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_to_text.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_to_text.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_to_text.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_to_text.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_to_text.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_to_text.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"dataclass_with_extra":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.dataclass_with_extra","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/image_to_text.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/image_to_text.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/image_to_text.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..934c23e70c7e7b18e6dead5b3d36142cf293bc9f --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/image_to_text.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[8,6,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["huggingface_hub.inference._generated.types.base","typing","builtins","_frozen_importlib","_typeshed","abc"],"hash":"65df4880a68ec0f4213249959b74a35012da984d","id":"huggingface_hub.inference._generated.types.image_to_text","ignore_all":true,"interface_hash":"81d08b73541c29fca534d7012db38d3836e3d793","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/image_to_text.py","plugin_data":null,"size":4810,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/image_to_video.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/image_to_video.data.json new file mode 100644 index 0000000000000000000000000000000000000000..1e3a714e3f57f370cd0bcfa27206bb89581e028f --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/image_to_video.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._generated.types.image_to_video","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseInferenceType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.BaseInferenceType","kind":"Gdef"},"ImageToVideoInput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.image_to_video.ImageToVideoInput","name":"ImageToVideoInput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.image_to_video.ImageToVideoInput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.image_to_video","mro":["huggingface_hub.inference._generated.types.image_to_video.ImageToVideoInput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","inputs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_to_video.ImageToVideoInput.inputs","name":"inputs","setter_type":null,"type":"builtins.str"}},"parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_to_video.ImageToVideoInput.parameters","name":"parameters","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.image_to_video.ImageToVideoParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.image_to_video.ImageToVideoInput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.image_to_video.ImageToVideoInput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ImageToVideoOutput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.image_to_video.ImageToVideoOutput","name":"ImageToVideoOutput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.image_to_video.ImageToVideoOutput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.image_to_video","mro":["huggingface_hub.inference._generated.types.image_to_video.ImageToVideoOutput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","video":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_to_video.ImageToVideoOutput.video","name":"video","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.image_to_video.ImageToVideoOutput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.image_to_video.ImageToVideoOutput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ImageToVideoParameters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.image_to_video.ImageToVideoParameters","name":"ImageToVideoParameters","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.image_to_video.ImageToVideoParameters","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.image_to_video","mro":["huggingface_hub.inference._generated.types.image_to_video.ImageToVideoParameters","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","guidance_scale":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_to_video.ImageToVideoParameters.guidance_scale","name":"guidance_scale","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"negative_prompt":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_to_video.ImageToVideoParameters.negative_prompt","name":"negative_prompt","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"num_frames":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_to_video.ImageToVideoParameters.num_frames","name":"num_frames","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"num_inference_steps":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_to_video.ImageToVideoParameters.num_inference_steps","name":"num_inference_steps","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"prompt":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_to_video.ImageToVideoParameters.prompt","name":"prompt","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"seed":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_to_video.ImageToVideoParameters.seed","name":"seed","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"target_size":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.image_to_video.ImageToVideoParameters.target_size","name":"target_size","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.image_to_video.ImageToVideoTargetSize",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.image_to_video.ImageToVideoParameters.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.image_to_video.ImageToVideoParameters","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ImageToVideoTargetSize":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.image_to_video.ImageToVideoTargetSize","name":"ImageToVideoTargetSize","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.image_to_video.ImageToVideoTargetSize","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.image_to_video","mro":["huggingface_hub.inference._generated.types.image_to_video.ImageToVideoTargetSize","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","height":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_to_video.ImageToVideoTargetSize.height","name":"height","setter_type":null,"type":"builtins.int"}},"width":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_to_video.ImageToVideoTargetSize.width","name":"width","setter_type":null,"type":"builtins.int"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.image_to_video.ImageToVideoTargetSize.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.image_to_video.ImageToVideoTargetSize","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_to_video.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_to_video.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_to_video.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_to_video.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_to_video.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.image_to_video.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"dataclass_with_extra":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.dataclass_with_extra","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/image_to_video.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/image_to_video.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/image_to_video.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..c7acbf6b44ef157613a09fed9b2d6474c40e2a63 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/image_to_video.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[8,6,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["huggingface_hub.inference._generated.types.base","typing","builtins","_frozen_importlib","_typeshed","abc"],"hash":"71405dca6214501f27a3262b911dbf787c293979","id":"huggingface_hub.inference._generated.types.image_to_video","ignore_all":true,"interface_hash":"859e7ed8197e6fe542f06b1731b5427ea31c4bf7","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/image_to_video.py","plugin_data":null,"size":2240,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/object_detection.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/object_detection.data.json new file mode 100644 index 0000000000000000000000000000000000000000..9a6c5d5efb85c5bd8fc03fc0f0563f56a1b48b90 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/object_detection.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._generated.types.object_detection","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","BaseInferenceType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.BaseInferenceType","kind":"Gdef"},"ObjectDetectionBoundingBox":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.object_detection.ObjectDetectionBoundingBox","name":"ObjectDetectionBoundingBox","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.object_detection.ObjectDetectionBoundingBox","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.object_detection","mro":["huggingface_hub.inference._generated.types.object_detection.ObjectDetectionBoundingBox","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","xmax":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.object_detection.ObjectDetectionBoundingBox.xmax","name":"xmax","setter_type":null,"type":"builtins.int"}},"xmin":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.object_detection.ObjectDetectionBoundingBox.xmin","name":"xmin","setter_type":null,"type":"builtins.int"}},"ymax":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.object_detection.ObjectDetectionBoundingBox.ymax","name":"ymax","setter_type":null,"type":"builtins.int"}},"ymin":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.object_detection.ObjectDetectionBoundingBox.ymin","name":"ymin","setter_type":null,"type":"builtins.int"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.object_detection.ObjectDetectionBoundingBox.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.object_detection.ObjectDetectionBoundingBox","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ObjectDetectionInput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.object_detection.ObjectDetectionInput","name":"ObjectDetectionInput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.object_detection.ObjectDetectionInput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.object_detection","mro":["huggingface_hub.inference._generated.types.object_detection.ObjectDetectionInput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","inputs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.object_detection.ObjectDetectionInput.inputs","name":"inputs","setter_type":null,"type":"builtins.str"}},"parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.object_detection.ObjectDetectionInput.parameters","name":"parameters","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.object_detection.ObjectDetectionParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.object_detection.ObjectDetectionInput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.object_detection.ObjectDetectionInput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ObjectDetectionOutputElement":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.object_detection.ObjectDetectionOutputElement","name":"ObjectDetectionOutputElement","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.object_detection.ObjectDetectionOutputElement","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.object_detection","mro":["huggingface_hub.inference._generated.types.object_detection.ObjectDetectionOutputElement","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","box":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.object_detection.ObjectDetectionOutputElement.box","name":"box","setter_type":null,"type":"huggingface_hub.inference._generated.types.object_detection.ObjectDetectionBoundingBox"}},"label":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.object_detection.ObjectDetectionOutputElement.label","name":"label","setter_type":null,"type":"builtins.str"}},"score":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.object_detection.ObjectDetectionOutputElement.score","name":"score","setter_type":null,"type":"builtins.float"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.object_detection.ObjectDetectionOutputElement.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.object_detection.ObjectDetectionOutputElement","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ObjectDetectionParameters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.object_detection.ObjectDetectionParameters","name":"ObjectDetectionParameters","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.object_detection.ObjectDetectionParameters","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.object_detection","mro":["huggingface_hub.inference._generated.types.object_detection.ObjectDetectionParameters","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","threshold":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.object_detection.ObjectDetectionParameters.threshold","name":"threshold","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.object_detection.ObjectDetectionParameters.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.object_detection.ObjectDetectionParameters","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.object_detection.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.object_detection.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.object_detection.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.object_detection.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.object_detection.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.object_detection.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"dataclass_with_extra":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.dataclass_with_extra","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/object_detection.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/object_detection.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/object_detection.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..c5141249d80d26643ae05f89e1024fea0932d0df --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/object_detection.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[8,6,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["huggingface_hub.inference._generated.types.base","typing","builtins","_frozen_importlib","_typeshed","abc"],"hash":"e02fc31c7c939cf57a6b1c5173a1562ecc81d8d2","id":"huggingface_hub.inference._generated.types.object_detection","ignore_all":true,"interface_hash":"6c1e4e7ddc56904effc69c11e5eeaad0963327e7","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/object_detection.py","plugin_data":null,"size":2000,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/question_answering.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/question_answering.data.json new file mode 100644 index 0000000000000000000000000000000000000000..51c0c150a068442f04e459b6ff39d0f6cbe951e1 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/question_answering.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._generated.types.question_answering","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","BaseInferenceType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.BaseInferenceType","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"QuestionAnsweringInput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringInput","name":"QuestionAnsweringInput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringInput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.question_answering","mro":["huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringInput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","inputs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringInput.inputs","name":"inputs","setter_type":null,"type":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringInputData"}},"parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringInput.parameters","name":"parameters","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringInput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringInput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"QuestionAnsweringInputData":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringInputData","name":"QuestionAnsweringInputData","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringInputData","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.question_answering","mro":["huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringInputData","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","context":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringInputData.context","name":"context","setter_type":null,"type":"builtins.str"}},"question":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringInputData.question","name":"question","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringInputData.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringInputData","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"QuestionAnsweringOutputElement":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringOutputElement","name":"QuestionAnsweringOutputElement","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringOutputElement","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.question_answering","mro":["huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringOutputElement","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","answer":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringOutputElement.answer","name":"answer","setter_type":null,"type":"builtins.str"}},"end":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringOutputElement.end","name":"end","setter_type":null,"type":"builtins.int"}},"score":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringOutputElement.score","name":"score","setter_type":null,"type":"builtins.float"}},"start":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringOutputElement.start","name":"start","setter_type":null,"type":"builtins.int"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringOutputElement.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringOutputElement","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"QuestionAnsweringParameters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringParameters","name":"QuestionAnsweringParameters","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringParameters","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.question_answering","mro":["huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringParameters","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","align_to_words":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringParameters.align_to_words","name":"align_to_words","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"doc_stride":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringParameters.doc_stride","name":"doc_stride","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"handle_impossible_answer":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringParameters.handle_impossible_answer","name":"handle_impossible_answer","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"max_answer_len":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringParameters.max_answer_len","name":"max_answer_len","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"max_question_len":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringParameters.max_question_len","name":"max_question_len","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"max_seq_len":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringParameters.max_seq_len","name":"max_seq_len","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"top_k":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringParameters.top_k","name":"top_k","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringParameters.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.question_answering.QuestionAnsweringParameters","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.question_answering.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.question_answering.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.question_answering.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.question_answering.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.question_answering.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.question_answering.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"dataclass_with_extra":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.dataclass_with_extra","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/question_answering.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/question_answering.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/question_answering.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..af27eba96e725246acedd45c29a9f56d1ee973cc --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/question_answering.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[8,6,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["huggingface_hub.inference._generated.types.base","typing","builtins","_frozen_importlib","_typeshed","abc"],"hash":"9b6d2403c208d1119ec27df61ee3adcd4880783e","id":"huggingface_hub.inference._generated.types.question_answering","ignore_all":true,"interface_hash":"7bba947c310a6016396678ab948ab782257d44db","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/question_answering.py","plugin_data":null,"size":2898,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/sentence_similarity.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/sentence_similarity.data.json new file mode 100644 index 0000000000000000000000000000000000000000..d1ec255ba5d1cf5ad063a157dfdfce5ccf05cbed --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/sentence_similarity.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._generated.types.sentence_similarity","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseInferenceType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.BaseInferenceType","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"SentenceSimilarityInput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.sentence_similarity.SentenceSimilarityInput","name":"SentenceSimilarityInput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.sentence_similarity.SentenceSimilarityInput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.sentence_similarity","mro":["huggingface_hub.inference._generated.types.sentence_similarity.SentenceSimilarityInput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","inputs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.sentence_similarity.SentenceSimilarityInput.inputs","name":"inputs","setter_type":null,"type":"huggingface_hub.inference._generated.types.sentence_similarity.SentenceSimilarityInputData"}},"parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.sentence_similarity.SentenceSimilarityInput.parameters","name":"parameters","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.sentence_similarity.SentenceSimilarityInput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.sentence_similarity.SentenceSimilarityInput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"SentenceSimilarityInputData":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.sentence_similarity.SentenceSimilarityInputData","name":"SentenceSimilarityInputData","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.sentence_similarity.SentenceSimilarityInputData","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.sentence_similarity","mro":["huggingface_hub.inference._generated.types.sentence_similarity.SentenceSimilarityInputData","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","sentences":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.sentence_similarity.SentenceSimilarityInputData.sentences","name":"sentences","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"source_sentence":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.sentence_similarity.SentenceSimilarityInputData.source_sentence","name":"source_sentence","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.sentence_similarity.SentenceSimilarityInputData.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.sentence_similarity.SentenceSimilarityInputData","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.sentence_similarity.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.sentence_similarity.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.sentence_similarity.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.sentence_similarity.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.sentence_similarity.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.sentence_similarity.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"dataclass_with_extra":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.dataclass_with_extra","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/sentence_similarity.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/sentence_similarity.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/sentence_similarity.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..6a15c63d13c5f1229fdf65133bec6381ba98d1af --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/sentence_similarity.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[8,6,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["huggingface_hub.inference._generated.types.base","typing","builtins","_frozen_importlib","_typeshed","abc"],"hash":"3ca56916504aade9f8ec0718305ef64baa37234a","id":"huggingface_hub.inference._generated.types.sentence_similarity","ignore_all":true,"interface_hash":"1a7cbc6299b7234ff452835e454dcfdc1283e9b6","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/sentence_similarity.py","plugin_data":null,"size":1040,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/summarization.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/summarization.data.json new file mode 100644 index 0000000000000000000000000000000000000000..003a283528e61019df156b840022cef7a4247829 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/summarization.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._generated.types.summarization","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseInferenceType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.BaseInferenceType","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"SummarizationInput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.summarization.SummarizationInput","name":"SummarizationInput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.summarization.SummarizationInput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.summarization","mro":["huggingface_hub.inference._generated.types.summarization.SummarizationInput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","inputs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.summarization.SummarizationInput.inputs","name":"inputs","setter_type":null,"type":"builtins.str"}},"parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.summarization.SummarizationInput.parameters","name":"parameters","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.summarization.SummarizationParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.summarization.SummarizationInput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.summarization.SummarizationInput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"SummarizationOutput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.summarization.SummarizationOutput","name":"SummarizationOutput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.summarization.SummarizationOutput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.summarization","mro":["huggingface_hub.inference._generated.types.summarization.SummarizationOutput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","summary_text":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.summarization.SummarizationOutput.summary_text","name":"summary_text","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.summarization.SummarizationOutput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.summarization.SummarizationOutput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"SummarizationParameters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.summarization.SummarizationParameters","name":"SummarizationParameters","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.summarization.SummarizationParameters","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.summarization","mro":["huggingface_hub.inference._generated.types.summarization.SummarizationParameters","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","clean_up_tokenization_spaces":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.summarization.SummarizationParameters.clean_up_tokenization_spaces","name":"clean_up_tokenization_spaces","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"generate_parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.summarization.SummarizationParameters.generate_parameters","name":"generate_parameters","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"truncation":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.summarization.SummarizationParameters.truncation","name":"truncation","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.summarization.SummarizationTruncationStrategy"},{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.summarization.SummarizationParameters.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.summarization.SummarizationParameters","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"SummarizationTruncationStrategy":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.inference._generated.types.summarization.SummarizationTruncationStrategy","line":11,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"do_not_truncate"},{".class":"LiteralType","fallback":"builtins.str","value":"longest_first"},{".class":"LiteralType","fallback":"builtins.str","value":"only_first"},{".class":"LiteralType","fallback":"builtins.str","value":"only_second"}],"uses_pep604_syntax":false}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.summarization.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.summarization.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.summarization.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.summarization.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.summarization.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.summarization.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"dataclass_with_extra":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.dataclass_with_extra","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/summarization.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/summarization.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/summarization.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..8da7480f79b0b1c2d6b4d91cc36d885f9b27fd71 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/summarization.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[8,6,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["huggingface_hub.inference._generated.types.base","typing","builtins","_frozen_importlib","_typeshed","abc"],"hash":"4ec5e23cd46ad505e5e94d5b024b11407a0e03fe","id":"huggingface_hub.inference._generated.types.summarization","ignore_all":true,"interface_hash":"5ec81dedaf2ba1ef54923dd5ae4b1cdd8ee3c936","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/summarization.py","plugin_data":null,"size":1481,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/table_question_answering.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/table_question_answering.data.json new file mode 100644 index 0000000000000000000000000000000000000000..2fa6bc572d52338ed2903b9deff7128cab17ab1a --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/table_question_answering.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._generated.types.table_question_answering","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","BaseInferenceType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.BaseInferenceType","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"Padding":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.inference._generated.types.table_question_answering.Padding","line":21,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"do_not_pad"},{".class":"LiteralType","fallback":"builtins.str","value":"longest"},{".class":"LiteralType","fallback":"builtins.str","value":"max_length"}],"uses_pep604_syntax":false}}},"TableQuestionAnsweringInput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringInput","name":"TableQuestionAnsweringInput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringInput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.table_question_answering","mro":["huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringInput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","inputs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringInput.inputs","name":"inputs","setter_type":null,"type":"huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringInputData"}},"parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringInput.parameters","name":"parameters","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringInput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringInput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TableQuestionAnsweringInputData":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringInputData","name":"TableQuestionAnsweringInputData","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringInputData","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.table_question_answering","mro":["huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringInputData","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","question":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringInputData.question","name":"question","setter_type":null,"type":"builtins.str"}},"table":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringInputData.table","name":"table","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"builtins.dict"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringInputData.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringInputData","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TableQuestionAnsweringOutputElement":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringOutputElement","name":"TableQuestionAnsweringOutputElement","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringOutputElement","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.table_question_answering","mro":["huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringOutputElement","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","aggregator":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringOutputElement.aggregator","name":"aggregator","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"answer":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringOutputElement.answer","name":"answer","setter_type":null,"type":"builtins.str"}},"cells":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringOutputElement.cells","name":"cells","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"coordinates":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringOutputElement.coordinates","name":"coordinates","setter_type":null,"type":{".class":"Instance","args":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"builtins.list"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringOutputElement.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringOutputElement","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TableQuestionAnsweringParameters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringParameters","name":"TableQuestionAnsweringParameters","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringParameters","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.table_question_answering","mro":["huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringParameters","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","padding":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringParameters.padding","name":"padding","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.table_question_answering.Padding"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"sequential":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringParameters.sequential","name":"sequential","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"truncation":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringParameters.truncation","name":"truncation","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringParameters.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.table_question_answering.TableQuestionAnsweringParameters","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.table_question_answering.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.table_question_answering.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.table_question_answering.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.table_question_answering.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.table_question_answering.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.table_question_answering.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"dataclass_with_extra":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.dataclass_with_extra","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/table_question_answering.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/table_question_answering.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/table_question_answering.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..3a70a6dfd350673145ed9b27f43a5e81eb66294a --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/table_question_answering.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[8,6,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["huggingface_hub.inference._generated.types.base","typing","builtins","_frozen_importlib","_typeshed","abc"],"hash":"6fffa028b27773391d70ef4083902d7223a8b940","id":"huggingface_hub.inference._generated.types.table_question_answering","ignore_all":true,"interface_hash":"236fbc3fa191407092801e49d32daa4e37ff1def","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/table_question_answering.py","plugin_data":null,"size":2281,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text2text_generation.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text2text_generation.data.json new file mode 100644 index 0000000000000000000000000000000000000000..f94367692c390663999db5d9cd65331c670936e6 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text2text_generation.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._generated.types.text2text_generation","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseInferenceType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.BaseInferenceType","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"Text2TextGenerationInput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.text2text_generation.Text2TextGenerationInput","name":"Text2TextGenerationInput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.text2text_generation.Text2TextGenerationInput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.text2text_generation","mro":["huggingface_hub.inference._generated.types.text2text_generation.Text2TextGenerationInput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","inputs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text2text_generation.Text2TextGenerationInput.inputs","name":"inputs","setter_type":null,"type":"builtins.str"}},"parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text2text_generation.Text2TextGenerationInput.parameters","name":"parameters","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text2text_generation.Text2TextGenerationParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.text2text_generation.Text2TextGenerationInput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.text2text_generation.Text2TextGenerationInput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Text2TextGenerationOutput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.text2text_generation.Text2TextGenerationOutput","name":"Text2TextGenerationOutput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.text2text_generation.Text2TextGenerationOutput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.text2text_generation","mro":["huggingface_hub.inference._generated.types.text2text_generation.Text2TextGenerationOutput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","generated_text":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text2text_generation.Text2TextGenerationOutput.generated_text","name":"generated_text","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"text2_text_generation_output_generated_text":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text2text_generation.Text2TextGenerationOutput.text2_text_generation_output_generated_text","name":"text2_text_generation_output_generated_text","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.text2text_generation.Text2TextGenerationOutput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.text2text_generation.Text2TextGenerationOutput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Text2TextGenerationParameters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.text2text_generation.Text2TextGenerationParameters","name":"Text2TextGenerationParameters","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.text2text_generation.Text2TextGenerationParameters","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.text2text_generation","mro":["huggingface_hub.inference._generated.types.text2text_generation.Text2TextGenerationParameters","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","clean_up_tokenization_spaces":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text2text_generation.Text2TextGenerationParameters.clean_up_tokenization_spaces","name":"clean_up_tokenization_spaces","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"generate_parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text2text_generation.Text2TextGenerationParameters.generate_parameters","name":"generate_parameters","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"truncation":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text2text_generation.Text2TextGenerationParameters.truncation","name":"truncation","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.text2text_generation.Text2TextGenerationTruncationStrategy"},{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.text2text_generation.Text2TextGenerationParameters.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.text2text_generation.Text2TextGenerationParameters","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Text2TextGenerationTruncationStrategy":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.inference._generated.types.text2text_generation.Text2TextGenerationTruncationStrategy","line":11,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"do_not_truncate"},{".class":"LiteralType","fallback":"builtins.str","value":"longest_first"},{".class":"LiteralType","fallback":"builtins.str","value":"only_first"},{".class":"LiteralType","fallback":"builtins.str","value":"only_second"}],"uses_pep604_syntax":false}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text2text_generation.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text2text_generation.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text2text_generation.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text2text_generation.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text2text_generation.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text2text_generation.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"dataclass_with_extra":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.dataclass_with_extra","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/text2text_generation.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text2text_generation.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text2text_generation.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..5087e404335ac8b1bcc5af8e32b646370f6d2114 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text2text_generation.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[8,6,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["huggingface_hub.inference._generated.types.base","typing","builtins","_frozen_importlib","_typeshed","abc"],"hash":"b4fd843175fd24508b85a81d4551917b3a3ee5c4","id":"huggingface_hub.inference._generated.types.text2text_generation","ignore_all":true,"interface_hash":"208f80f50ddb56d8145071c03c25a52c06ac9b09","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/text2text_generation.py","plugin_data":null,"size":1603,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text_classification.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text_classification.data.json new file mode 100644 index 0000000000000000000000000000000000000000..2a4fda6706c2a05c78da7b3a16607af156ab4665 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text_classification.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._generated.types.text_classification","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","BaseInferenceType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.BaseInferenceType","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"TextClassificationInput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.text_classification.TextClassificationInput","name":"TextClassificationInput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.text_classification.TextClassificationInput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.text_classification","mro":["huggingface_hub.inference._generated.types.text_classification.TextClassificationInput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","inputs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_classification.TextClassificationInput.inputs","name":"inputs","setter_type":null,"type":"builtins.str"}},"parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_classification.TextClassificationInput.parameters","name":"parameters","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_classification.TextClassificationParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.text_classification.TextClassificationInput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.text_classification.TextClassificationInput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TextClassificationOutputElement":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.text_classification.TextClassificationOutputElement","name":"TextClassificationOutputElement","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.text_classification.TextClassificationOutputElement","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.text_classification","mro":["huggingface_hub.inference._generated.types.text_classification.TextClassificationOutputElement","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","label":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_classification.TextClassificationOutputElement.label","name":"label","setter_type":null,"type":"builtins.str"}},"score":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_classification.TextClassificationOutputElement.score","name":"score","setter_type":null,"type":"builtins.float"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.text_classification.TextClassificationOutputElement.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.text_classification.TextClassificationOutputElement","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TextClassificationOutputTransform":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.inference._generated.types.text_classification.TextClassificationOutputTransform","line":11,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"sigmoid"},{".class":"LiteralType","fallback":"builtins.str","value":"softmax"},{".class":"LiteralType","fallback":"builtins.str","value":"none"}],"uses_pep604_syntax":false}}},"TextClassificationParameters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.text_classification.TextClassificationParameters","name":"TextClassificationParameters","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.text_classification.TextClassificationParameters","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.text_classification","mro":["huggingface_hub.inference._generated.types.text_classification.TextClassificationParameters","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","function_to_apply":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_classification.TextClassificationParameters.function_to_apply","name":"function_to_apply","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.text_classification.TextClassificationOutputTransform"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"top_k":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_classification.TextClassificationParameters.top_k","name":"top_k","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.text_classification.TextClassificationParameters.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.text_classification.TextClassificationParameters","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_classification.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_classification.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_classification.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_classification.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_classification.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_classification.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"dataclass_with_extra":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.dataclass_with_extra","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/text_classification.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text_classification.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text_classification.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..e3938ba2cb179f818d4a1e0404e8788d87384a8c --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text_classification.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[8,6,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["huggingface_hub.inference._generated.types.base","typing","builtins","_frozen_importlib","_typeshed","abc"],"hash":"828113436dfc34527d6b24a6a42082eb4c916d20","id":"huggingface_hub.inference._generated.types.text_classification","ignore_all":true,"interface_hash":"403504ec7aad96019bfa1ca999f19ff89aaae186","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/text_classification.py","plugin_data":null,"size":1445,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text_generation.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text_generation.data.json new file mode 100644 index 0000000000000000000000000000000000000000..93e23eaed98dfc5ebbd931f11fc774852cfa9744 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text_generation.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._generated.types.text_generation","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseInferenceType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.BaseInferenceType","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"TextGenerationInput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInput","name":"TextGenerationInput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.text_generation","mro":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","inputs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInput.inputs","name":"inputs","setter_type":null,"type":"builtins.str"}},"parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInput.parameters","name":"parameters","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGenerateParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"stream":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInput.stream","name":"stream","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TextGenerationInputGenerateParameters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGenerateParameters","name":"TextGenerationInputGenerateParameters","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGenerateParameters","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.text_generation","mro":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGenerateParameters","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","adapter_id":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGenerateParameters.adapter_id","name":"adapter_id","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"best_of":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGenerateParameters.best_of","name":"best_of","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"decoder_input_details":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGenerateParameters.decoder_input_details","name":"decoder_input_details","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"details":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGenerateParameters.details","name":"details","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"do_sample":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGenerateParameters.do_sample","name":"do_sample","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"frequency_penalty":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGenerateParameters.frequency_penalty","name":"frequency_penalty","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"grammar":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGenerateParameters.grammar","name":"grammar","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"max_new_tokens":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGenerateParameters.max_new_tokens","name":"max_new_tokens","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"repetition_penalty":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGenerateParameters.repetition_penalty","name":"repetition_penalty","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"return_full_text":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGenerateParameters.return_full_text","name":"return_full_text","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"seed":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGenerateParameters.seed","name":"seed","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"stop":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGenerateParameters.stop","name":"stop","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"temperature":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGenerateParameters.temperature","name":"temperature","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"top_k":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGenerateParameters.top_k","name":"top_k","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"top_n_tokens":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGenerateParameters.top_n_tokens","name":"top_n_tokens","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"top_p":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGenerateParameters.top_p","name":"top_p","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"truncate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGenerateParameters.truncate","name":"truncate","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"typical_p":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGenerateParameters.typical_p","name":"typical_p","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"watermark":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGenerateParameters.watermark","name":"watermark","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGenerateParameters.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGenerateParameters","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TextGenerationInputGrammarType":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType","name":"TextGenerationInputGrammarType","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.text_generation","mro":["huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","type":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType.type","name":"type","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.text_generation.TypeEnum"}}},"value":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType.value","name":"value","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TextGenerationOutput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutput","name":"TextGenerationOutput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.text_generation","mro":["huggingface_hub.inference._generated.types.text_generation.TextGenerationOutput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","details":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutput.details","name":"details","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputDetails",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"generated_text":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutput.generated_text","name":"generated_text","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TextGenerationOutputBestOfSequence":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputBestOfSequence","name":"TextGenerationOutputBestOfSequence","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputBestOfSequence","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.text_generation","mro":["huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputBestOfSequence","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","finish_reason":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputBestOfSequence.finish_reason","name":"finish_reason","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputFinishReason"}}},"generated_text":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputBestOfSequence.generated_text","name":"generated_text","setter_type":null,"type":"builtins.str"}},"generated_tokens":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputBestOfSequence.generated_tokens","name":"generated_tokens","setter_type":null,"type":"builtins.int"}},"prefill":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputBestOfSequence.prefill","name":"prefill","setter_type":null,"type":{".class":"Instance","args":["huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputPrefillToken"],"extra_attrs":null,"type_ref":"builtins.list"}}},"seed":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputBestOfSequence.seed","name":"seed","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"tokens":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputBestOfSequence.tokens","name":"tokens","setter_type":null,"type":{".class":"Instance","args":["huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputToken"],"extra_attrs":null,"type_ref":"builtins.list"}}},"top_tokens":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputBestOfSequence.top_tokens","name":"top_tokens","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"Instance","args":["huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputToken"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputBestOfSequence.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputBestOfSequence","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TextGenerationOutputDetails":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputDetails","name":"TextGenerationOutputDetails","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputDetails","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.text_generation","mro":["huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputDetails","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","best_of_sequences":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputDetails.best_of_sequences","name":"best_of_sequences","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputBestOfSequence"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"finish_reason":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputDetails.finish_reason","name":"finish_reason","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputFinishReason"}}},"generated_tokens":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputDetails.generated_tokens","name":"generated_tokens","setter_type":null,"type":"builtins.int"}},"prefill":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputDetails.prefill","name":"prefill","setter_type":null,"type":{".class":"Instance","args":["huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputPrefillToken"],"extra_attrs":null,"type_ref":"builtins.list"}}},"seed":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputDetails.seed","name":"seed","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"tokens":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputDetails.tokens","name":"tokens","setter_type":null,"type":{".class":"Instance","args":["huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputToken"],"extra_attrs":null,"type_ref":"builtins.list"}}},"top_tokens":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputDetails.top_tokens","name":"top_tokens","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"Instance","args":["huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputToken"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputDetails.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputDetails","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TextGenerationOutputFinishReason":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputFinishReason","line":88,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"length"},{".class":"LiteralType","fallback":"builtins.str","value":"eos_token"},{".class":"LiteralType","fallback":"builtins.str","value":"stop_sequence"}],"uses_pep604_syntax":false}}},"TextGenerationOutputPrefillToken":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputPrefillToken","name":"TextGenerationOutputPrefillToken","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputPrefillToken","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.text_generation","mro":["huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputPrefillToken","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","id":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputPrefillToken.id","name":"id","setter_type":null,"type":"builtins.int"}},"logprob":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputPrefillToken.logprob","name":"logprob","setter_type":null,"type":"builtins.float"}},"text":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputPrefillToken.text","name":"text","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputPrefillToken.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputPrefillToken","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TextGenerationOutputToken":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputToken","name":"TextGenerationOutputToken","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputToken","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.text_generation","mro":["huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputToken","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","id":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputToken.id","name":"id","setter_type":null,"type":"builtins.int"}},"logprob":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputToken.logprob","name":"logprob","setter_type":null,"type":"builtins.float"}},"special":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputToken.special","name":"special","setter_type":null,"type":"builtins.bool"}},"text":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputToken.text","name":"text","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputToken.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputToken","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TextGenerationStreamOutput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutput","name":"TextGenerationStreamOutput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.text_generation","mro":["huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","details":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutput.details","name":"details","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutputStreamDetails",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"generated_text":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutput.generated_text","name":"generated_text","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"index":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutput.index","name":"index","setter_type":null,"type":"builtins.int"}},"token":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutput.token","name":"token","setter_type":null,"type":"huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutputToken"}},"top_tokens":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutput.top_tokens","name":"top_tokens","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutputToken"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TextGenerationStreamOutputStreamDetails":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutputStreamDetails","name":"TextGenerationStreamOutputStreamDetails","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutputStreamDetails","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.text_generation","mro":["huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutputStreamDetails","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","finish_reason":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutputStreamDetails.finish_reason","name":"finish_reason","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.text_generation.TextGenerationOutputFinishReason"}}},"generated_tokens":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutputStreamDetails.generated_tokens","name":"generated_tokens","setter_type":null,"type":"builtins.int"}},"input_length":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutputStreamDetails.input_length","name":"input_length","setter_type":null,"type":"builtins.int"}},"seed":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutputStreamDetails.seed","name":"seed","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutputStreamDetails.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutputStreamDetails","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TextGenerationStreamOutputToken":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutputToken","name":"TextGenerationStreamOutputToken","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutputToken","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.text_generation","mro":["huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutputToken","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","id":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutputToken.id","name":"id","setter_type":null,"type":"builtins.int"}},"logprob":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutputToken.logprob","name":"logprob","setter_type":null,"type":"builtins.float"}},"special":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutputToken.special","name":"special","setter_type":null,"type":"builtins.bool"}},"text":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutputToken.text","name":"text","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutputToken.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.text_generation.TextGenerationStreamOutputToken","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TypeEnum":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.inference._generated.types.text_generation.TypeEnum","line":11,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"json"},{".class":"LiteralType","fallback":"builtins.str","value":"regex"},{".class":"LiteralType","fallback":"builtins.str","value":"json_schema"}],"uses_pep604_syntax":false}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_generation.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_generation.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_generation.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_generation.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_generation.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_generation.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"dataclass_with_extra":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.dataclass_with_extra","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/text_generation.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text_generation.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text_generation.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..f2f3a1ca694768e4dc20b57f982419b7b6b9f693 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text_generation.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[8,6,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["huggingface_hub.inference._generated.types.base","typing","builtins","_frozen_importlib","_typeshed","abc"],"hash":"517ea5d2526e681e482584585a90ec5ab27b205d","id":"huggingface_hub.inference._generated.types.text_generation","ignore_all":true,"interface_hash":"9506609505694f10a2299e7f7b3cc0d49b4419bb","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/text_generation.py","plugin_data":null,"size":5916,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text_to_audio.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text_to_audio.data.json new file mode 100644 index 0000000000000000000000000000000000000000..86d8d46d8c6a2dd2f28c97f6b247aca098859659 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text_to_audio.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._generated.types.text_to_audio","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseInferenceType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.BaseInferenceType","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"TextToAudioEarlyStoppingEnum":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioEarlyStoppingEnum","line":11,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"LiteralType","fallback":"builtins.str","value":"never"}}},"TextToAudioGenerationParameters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioGenerationParameters","name":"TextToAudioGenerationParameters","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioGenerationParameters","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.text_to_audio","mro":["huggingface_hub.inference._generated.types.text_to_audio.TextToAudioGenerationParameters","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","do_sample":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioGenerationParameters.do_sample","name":"do_sample","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"early_stopping":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioGenerationParameters.early_stopping","name":"early_stopping","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioEarlyStoppingEnum"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"epsilon_cutoff":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioGenerationParameters.epsilon_cutoff","name":"epsilon_cutoff","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"eta_cutoff":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioGenerationParameters.eta_cutoff","name":"eta_cutoff","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"max_length":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioGenerationParameters.max_length","name":"max_length","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"max_new_tokens":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioGenerationParameters.max_new_tokens","name":"max_new_tokens","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"min_length":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioGenerationParameters.min_length","name":"min_length","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"min_new_tokens":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioGenerationParameters.min_new_tokens","name":"min_new_tokens","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"num_beam_groups":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioGenerationParameters.num_beam_groups","name":"num_beam_groups","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"num_beams":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioGenerationParameters.num_beams","name":"num_beams","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"penalty_alpha":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioGenerationParameters.penalty_alpha","name":"penalty_alpha","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"temperature":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioGenerationParameters.temperature","name":"temperature","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"top_k":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioGenerationParameters.top_k","name":"top_k","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"top_p":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioGenerationParameters.top_p","name":"top_p","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"typical_p":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioGenerationParameters.typical_p","name":"typical_p","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"use_cache":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioGenerationParameters.use_cache","name":"use_cache","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioGenerationParameters.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioGenerationParameters","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TextToAudioInput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioInput","name":"TextToAudioInput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioInput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.text_to_audio","mro":["huggingface_hub.inference._generated.types.text_to_audio.TextToAudioInput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","inputs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioInput.inputs","name":"inputs","setter_type":null,"type":"builtins.str"}},"parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioInput.parameters","name":"parameters","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_to_audio.TextToAudioParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioInput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioInput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TextToAudioOutput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioOutput","name":"TextToAudioOutput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioOutput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.text_to_audio","mro":["huggingface_hub.inference._generated.types.text_to_audio.TextToAudioOutput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","audio":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioOutput.audio","name":"audio","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"sampling_rate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioOutput.sampling_rate","name":"sampling_rate","setter_type":null,"type":"builtins.float"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioOutput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioOutput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TextToAudioParameters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioParameters","name":"TextToAudioParameters","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioParameters","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.text_to_audio","mro":["huggingface_hub.inference._generated.types.text_to_audio.TextToAudioParameters","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","generation_parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioParameters.generation_parameters","name":"generation_parameters","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_to_audio.TextToAudioGenerationParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioParameters.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.text_to_audio.TextToAudioParameters","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_to_audio.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_to_audio.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_to_audio.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_to_audio.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_to_audio.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_to_audio.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"dataclass_with_extra":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.dataclass_with_extra","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/text_to_audio.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text_to_audio.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text_to_audio.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..9f352b6d4f00ca108e94b4bd8cd1e52e4d75a33d --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text_to_audio.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[8,6,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["huggingface_hub.inference._generated.types.base","typing","builtins","_frozen_importlib","_typeshed","abc"],"hash":"ff54dedacfb1ba7f905d096f74aab374a79a5d25","id":"huggingface_hub.inference._generated.types.text_to_audio","ignore_all":true,"interface_hash":"074e744ab952c143d09c1fc31c171378d6963020","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/text_to_audio.py","plugin_data":null,"size":4741,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text_to_image.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text_to_image.data.json new file mode 100644 index 0000000000000000000000000000000000000000..73993767cf6fb96143f9559af9e336240763261f --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text_to_image.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._generated.types.text_to_image","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseInferenceType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.BaseInferenceType","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"TextToImageInput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.text_to_image.TextToImageInput","name":"TextToImageInput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.text_to_image.TextToImageInput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.text_to_image","mro":["huggingface_hub.inference._generated.types.text_to_image.TextToImageInput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","inputs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_to_image.TextToImageInput.inputs","name":"inputs","setter_type":null,"type":"builtins.str"}},"parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_image.TextToImageInput.parameters","name":"parameters","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_to_image.TextToImageParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.text_to_image.TextToImageInput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.text_to_image.TextToImageInput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TextToImageOutput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.text_to_image.TextToImageOutput","name":"TextToImageOutput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.text_to_image.TextToImageOutput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.text_to_image","mro":["huggingface_hub.inference._generated.types.text_to_image.TextToImageOutput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","image":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_to_image.TextToImageOutput.image","name":"image","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.text_to_image.TextToImageOutput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.text_to_image.TextToImageOutput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TextToImageParameters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.text_to_image.TextToImageParameters","name":"TextToImageParameters","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.text_to_image.TextToImageParameters","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.text_to_image","mro":["huggingface_hub.inference._generated.types.text_to_image.TextToImageParameters","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","guidance_scale":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_image.TextToImageParameters.guidance_scale","name":"guidance_scale","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"height":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_image.TextToImageParameters.height","name":"height","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"negative_prompt":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_image.TextToImageParameters.negative_prompt","name":"negative_prompt","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"num_inference_steps":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_image.TextToImageParameters.num_inference_steps","name":"num_inference_steps","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"scheduler":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_image.TextToImageParameters.scheduler","name":"scheduler","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"seed":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_image.TextToImageParameters.seed","name":"seed","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"width":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_image.TextToImageParameters.width","name":"width","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.text_to_image.TextToImageParameters.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.text_to_image.TextToImageParameters","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_to_image.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_to_image.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_to_image.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_to_image.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_to_image.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_to_image.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"dataclass_with_extra":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.dataclass_with_extra","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/text_to_image.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text_to_image.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text_to_image.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..66aeb85c28acff9d18f300352ce2e173e340ea02 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text_to_image.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[8,6,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["huggingface_hub.inference._generated.types.base","typing","builtins","_frozen_importlib","_typeshed","abc"],"hash":"10ec9a7576b7cb10d1ee92407d191303ecf637af","id":"huggingface_hub.inference._generated.types.text_to_image","ignore_all":true,"interface_hash":"8de065a2e1fbbc389e69323aa19b4c9a3015d987","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/text_to_image.py","plugin_data":null,"size":1903,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text_to_speech.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text_to_speech.data.json new file mode 100644 index 0000000000000000000000000000000000000000..23790ed24283cfb549e6ada16a4f0221732ce2c5 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text_to_speech.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._generated.types.text_to_speech","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseInferenceType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.BaseInferenceType","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"TextToSpeechEarlyStoppingEnum":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechEarlyStoppingEnum","line":11,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"LiteralType","fallback":"builtins.str","value":"never"}}},"TextToSpeechGenerationParameters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechGenerationParameters","name":"TextToSpeechGenerationParameters","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechGenerationParameters","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.text_to_speech","mro":["huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechGenerationParameters","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","do_sample":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechGenerationParameters.do_sample","name":"do_sample","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"early_stopping":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechGenerationParameters.early_stopping","name":"early_stopping","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechEarlyStoppingEnum"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"epsilon_cutoff":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechGenerationParameters.epsilon_cutoff","name":"epsilon_cutoff","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"eta_cutoff":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechGenerationParameters.eta_cutoff","name":"eta_cutoff","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"max_length":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechGenerationParameters.max_length","name":"max_length","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"max_new_tokens":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechGenerationParameters.max_new_tokens","name":"max_new_tokens","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"min_length":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechGenerationParameters.min_length","name":"min_length","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"min_new_tokens":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechGenerationParameters.min_new_tokens","name":"min_new_tokens","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"num_beam_groups":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechGenerationParameters.num_beam_groups","name":"num_beam_groups","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"num_beams":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechGenerationParameters.num_beams","name":"num_beams","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"penalty_alpha":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechGenerationParameters.penalty_alpha","name":"penalty_alpha","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"temperature":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechGenerationParameters.temperature","name":"temperature","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"top_k":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechGenerationParameters.top_k","name":"top_k","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"top_p":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechGenerationParameters.top_p","name":"top_p","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"typical_p":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechGenerationParameters.typical_p","name":"typical_p","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"use_cache":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechGenerationParameters.use_cache","name":"use_cache","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechGenerationParameters.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechGenerationParameters","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TextToSpeechInput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechInput","name":"TextToSpeechInput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechInput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.text_to_speech","mro":["huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechInput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","inputs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechInput.inputs","name":"inputs","setter_type":null,"type":"builtins.str"}},"parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechInput.parameters","name":"parameters","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechInput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechInput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TextToSpeechOutput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechOutput","name":"TextToSpeechOutput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechOutput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.text_to_speech","mro":["huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechOutput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","audio":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechOutput.audio","name":"audio","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"sampling_rate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechOutput.sampling_rate","name":"sampling_rate","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechOutput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechOutput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TextToSpeechParameters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechParameters","name":"TextToSpeechParameters","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechParameters","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.text_to_speech","mro":["huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechParameters","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","generation_parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechParameters.generation_parameters","name":"generation_parameters","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechGenerationParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechParameters.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.text_to_speech.TextToSpeechParameters","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_to_speech.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_to_speech.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_to_speech.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_to_speech.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_to_speech.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_to_speech.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"dataclass_with_extra":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.dataclass_with_extra","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/text_to_speech.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text_to_speech.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text_to_speech.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..f048ff2894200134d36b08986fe9b56b71a88c97 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text_to_speech.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[8,6,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["huggingface_hub.inference._generated.types.base","typing","builtins","_frozen_importlib","_typeshed","abc"],"hash":"232c34e37de7df163fc579ee718d599d1bb2c9c6","id":"huggingface_hub.inference._generated.types.text_to_speech","ignore_all":true,"interface_hash":"cdc0d16394cd03028d1b30a07a4186de4b85c706","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/text_to_speech.py","plugin_data":null,"size":4760,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text_to_video.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text_to_video.data.json new file mode 100644 index 0000000000000000000000000000000000000000..c08943a710b5ae182d65a01f37f9eeb358931aef --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text_to_video.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._generated.types.text_to_video","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseInferenceType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.BaseInferenceType","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"TextToVideoInput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.text_to_video.TextToVideoInput","name":"TextToVideoInput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.text_to_video.TextToVideoInput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.text_to_video","mro":["huggingface_hub.inference._generated.types.text_to_video.TextToVideoInput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","inputs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_to_video.TextToVideoInput.inputs","name":"inputs","setter_type":null,"type":"builtins.str"}},"parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_video.TextToVideoInput.parameters","name":"parameters","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.text_to_video.TextToVideoParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.text_to_video.TextToVideoInput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.text_to_video.TextToVideoInput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TextToVideoOutput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.text_to_video.TextToVideoOutput","name":"TextToVideoOutput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.text_to_video.TextToVideoOutput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.text_to_video","mro":["huggingface_hub.inference._generated.types.text_to_video.TextToVideoOutput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","video":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_to_video.TextToVideoOutput.video","name":"video","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.text_to_video.TextToVideoOutput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.text_to_video.TextToVideoOutput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TextToVideoParameters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.text_to_video.TextToVideoParameters","name":"TextToVideoParameters","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.text_to_video.TextToVideoParameters","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.text_to_video","mro":["huggingface_hub.inference._generated.types.text_to_video.TextToVideoParameters","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","guidance_scale":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_video.TextToVideoParameters.guidance_scale","name":"guidance_scale","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"negative_prompt":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_video.TextToVideoParameters.negative_prompt","name":"negative_prompt","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"num_frames":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_video.TextToVideoParameters.num_frames","name":"num_frames","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"num_inference_steps":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_video.TextToVideoParameters.num_inference_steps","name":"num_inference_steps","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"seed":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.text_to_video.TextToVideoParameters.seed","name":"seed","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.text_to_video.TextToVideoParameters.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.text_to_video.TextToVideoParameters","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_to_video.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_to_video.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_to_video.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_to_video.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_to_video.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.text_to_video.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"dataclass_with_extra":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.dataclass_with_extra","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/text_to_video.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text_to_video.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text_to_video.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..621f0fe7d265e154b53a90ac87d813473a0cf9db --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/text_to_video.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[8,6,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["huggingface_hub.inference._generated.types.base","typing","builtins","_frozen_importlib","_typeshed","abc"],"hash":"2bcbbc92ede3916afac793adfbb1beca8bc77955","id":"huggingface_hub.inference._generated.types.text_to_video","ignore_all":true,"interface_hash":"54d73d8201705b0c174d85242699510aafe8461c","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/text_to_video.py","plugin_data":null,"size":1784,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/token_classification.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/token_classification.data.json new file mode 100644 index 0000000000000000000000000000000000000000..66a4aa7eff94ee2d655006e5559ddadf24b9bcb9 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/token_classification.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._generated.types.token_classification","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","BaseInferenceType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.BaseInferenceType","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"TokenClassificationAggregationStrategy":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.inference._generated.types.token_classification.TokenClassificationAggregationStrategy","line":11,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"none"},{".class":"LiteralType","fallback":"builtins.str","value":"simple"},{".class":"LiteralType","fallback":"builtins.str","value":"first"},{".class":"LiteralType","fallback":"builtins.str","value":"average"},{".class":"LiteralType","fallback":"builtins.str","value":"max"}],"uses_pep604_syntax":false}}},"TokenClassificationInput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.token_classification.TokenClassificationInput","name":"TokenClassificationInput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.token_classification.TokenClassificationInput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.token_classification","mro":["huggingface_hub.inference._generated.types.token_classification.TokenClassificationInput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","inputs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.token_classification.TokenClassificationInput.inputs","name":"inputs","setter_type":null,"type":"builtins.str"}},"parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.token_classification.TokenClassificationInput.parameters","name":"parameters","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.token_classification.TokenClassificationParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.token_classification.TokenClassificationInput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.token_classification.TokenClassificationInput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TokenClassificationOutputElement":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.token_classification.TokenClassificationOutputElement","name":"TokenClassificationOutputElement","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.token_classification.TokenClassificationOutputElement","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.token_classification","mro":["huggingface_hub.inference._generated.types.token_classification.TokenClassificationOutputElement","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","end":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.token_classification.TokenClassificationOutputElement.end","name":"end","setter_type":null,"type":"builtins.int"}},"entity":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.token_classification.TokenClassificationOutputElement.entity","name":"entity","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"entity_group":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.token_classification.TokenClassificationOutputElement.entity_group","name":"entity_group","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"score":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.token_classification.TokenClassificationOutputElement.score","name":"score","setter_type":null,"type":"builtins.float"}},"start":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.token_classification.TokenClassificationOutputElement.start","name":"start","setter_type":null,"type":"builtins.int"}},"word":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.token_classification.TokenClassificationOutputElement.word","name":"word","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.token_classification.TokenClassificationOutputElement.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.token_classification.TokenClassificationOutputElement","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TokenClassificationParameters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.token_classification.TokenClassificationParameters","name":"TokenClassificationParameters","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.token_classification.TokenClassificationParameters","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.token_classification","mro":["huggingface_hub.inference._generated.types.token_classification.TokenClassificationParameters","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","aggregation_strategy":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.token_classification.TokenClassificationParameters.aggregation_strategy","name":"aggregation_strategy","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.token_classification.TokenClassificationAggregationStrategy"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"ignore_labels":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.token_classification.TokenClassificationParameters.ignore_labels","name":"ignore_labels","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"stride":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.token_classification.TokenClassificationParameters.stride","name":"stride","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.token_classification.TokenClassificationParameters.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.token_classification.TokenClassificationParameters","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.token_classification.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.token_classification.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.token_classification.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.token_classification.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.token_classification.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.token_classification.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"dataclass_with_extra":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.dataclass_with_extra","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/token_classification.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/token_classification.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/token_classification.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..dda4d535adc0a0eac12c5b8ffc206ed27a156e36 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/token_classification.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[8,6,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["huggingface_hub.inference._generated.types.base","typing","builtins","_frozen_importlib","_typeshed","abc"],"hash":"fb155d31e1fcd61019cd198ea25ce6d9aefd91a7","id":"huggingface_hub.inference._generated.types.token_classification","ignore_all":true,"interface_hash":"423a97cf94055a4162d7fd71061649d3bcafa7e5","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/token_classification.py","plugin_data":null,"size":1909,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/translation.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/translation.data.json new file mode 100644 index 0000000000000000000000000000000000000000..3584258e6a9290c3a7c1e9a9d26ba53889040938 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/translation.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._generated.types.translation","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseInferenceType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.BaseInferenceType","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"TranslationInput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.translation.TranslationInput","name":"TranslationInput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.translation.TranslationInput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.translation","mro":["huggingface_hub.inference._generated.types.translation.TranslationInput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","inputs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.translation.TranslationInput.inputs","name":"inputs","setter_type":null,"type":"builtins.str"}},"parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.translation.TranslationInput.parameters","name":"parameters","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.translation.TranslationParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.translation.TranslationInput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.translation.TranslationInput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TranslationOutput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.translation.TranslationOutput","name":"TranslationOutput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.translation.TranslationOutput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.translation","mro":["huggingface_hub.inference._generated.types.translation.TranslationOutput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","translation_text":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.translation.TranslationOutput.translation_text","name":"translation_text","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.translation.TranslationOutput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.translation.TranslationOutput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TranslationParameters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.translation.TranslationParameters","name":"TranslationParameters","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.translation.TranslationParameters","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.translation","mro":["huggingface_hub.inference._generated.types.translation.TranslationParameters","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","clean_up_tokenization_spaces":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.translation.TranslationParameters.clean_up_tokenization_spaces","name":"clean_up_tokenization_spaces","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"generate_parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.translation.TranslationParameters.generate_parameters","name":"generate_parameters","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"src_lang":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.translation.TranslationParameters.src_lang","name":"src_lang","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"tgt_lang":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.translation.TranslationParameters.tgt_lang","name":"tgt_lang","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"truncation":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.translation.TranslationParameters.truncation","name":"truncation","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.translation.TranslationTruncationStrategy"},{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.translation.TranslationParameters.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.translation.TranslationParameters","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TranslationTruncationStrategy":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.inference._generated.types.translation.TranslationTruncationStrategy","line":11,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"do_not_truncate"},{".class":"LiteralType","fallback":"builtins.str","value":"longest_first"},{".class":"LiteralType","fallback":"builtins.str","value":"only_first"},{".class":"LiteralType","fallback":"builtins.str","value":"only_second"}],"uses_pep604_syntax":false}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.translation.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.translation.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.translation.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.translation.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.translation.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.translation.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"dataclass_with_extra":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.dataclass_with_extra","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/translation.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/translation.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/translation.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..7e1b2c60bbeab07dd303bed77804f288db15fbc9 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/translation.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[8,6,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["huggingface_hub.inference._generated.types.base","typing","builtins","_frozen_importlib","_typeshed","abc"],"hash":"d5235f2c04fe2d822a7697b542a2e9737eec52ae","id":"huggingface_hub.inference._generated.types.translation","ignore_all":true,"interface_hash":"af9568dab470b82770de43ee4aead917b39d3351","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/translation.py","plugin_data":null,"size":1757,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/video_classification.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/video_classification.data.json new file mode 100644 index 0000000000000000000000000000000000000000..fc7c063d3fc3e254c86ecc900b7976fc36a88214 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/video_classification.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._generated.types.video_classification","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseInferenceType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.BaseInferenceType","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"VideoClassificationInput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.video_classification.VideoClassificationInput","name":"VideoClassificationInput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.video_classification.VideoClassificationInput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.video_classification","mro":["huggingface_hub.inference._generated.types.video_classification.VideoClassificationInput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","inputs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.video_classification.VideoClassificationInput.inputs","name":"inputs","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.video_classification.VideoClassificationInput.parameters","name":"parameters","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.video_classification.VideoClassificationParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.video_classification.VideoClassificationInput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.video_classification.VideoClassificationInput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"VideoClassificationOutputElement":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.video_classification.VideoClassificationOutputElement","name":"VideoClassificationOutputElement","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.video_classification.VideoClassificationOutputElement","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.video_classification","mro":["huggingface_hub.inference._generated.types.video_classification.VideoClassificationOutputElement","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","label":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.video_classification.VideoClassificationOutputElement.label","name":"label","setter_type":null,"type":"builtins.str"}},"score":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.video_classification.VideoClassificationOutputElement.score","name":"score","setter_type":null,"type":"builtins.float"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.video_classification.VideoClassificationOutputElement.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.video_classification.VideoClassificationOutputElement","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"VideoClassificationOutputTransform":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.inference._generated.types.video_classification.VideoClassificationOutputTransform","line":11,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"sigmoid"},{".class":"LiteralType","fallback":"builtins.str","value":"softmax"},{".class":"LiteralType","fallback":"builtins.str","value":"none"}],"uses_pep604_syntax":false}}},"VideoClassificationParameters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.video_classification.VideoClassificationParameters","name":"VideoClassificationParameters","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.video_classification.VideoClassificationParameters","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.video_classification","mro":["huggingface_hub.inference._generated.types.video_classification.VideoClassificationParameters","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","frame_sampling_rate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.video_classification.VideoClassificationParameters.frame_sampling_rate","name":"frame_sampling_rate","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"function_to_apply":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.video_classification.VideoClassificationParameters.function_to_apply","name":"function_to_apply","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._generated.types.video_classification.VideoClassificationOutputTransform"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"num_frames":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.video_classification.VideoClassificationParameters.num_frames","name":"num_frames","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"top_k":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.video_classification.VideoClassificationParameters.top_k","name":"top_k","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.video_classification.VideoClassificationParameters.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.video_classification.VideoClassificationParameters","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.video_classification.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.video_classification.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.video_classification.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.video_classification.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.video_classification.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.video_classification.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"dataclass_with_extra":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.dataclass_with_extra","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/video_classification.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/video_classification.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/video_classification.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..775d3c3961943b6c31e9bf218dd0065bd2076551 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/video_classification.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[8,6,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["huggingface_hub.inference._generated.types.base","typing","builtins","_frozen_importlib","_typeshed","abc"],"hash":"183a6a7689aac5dc78686e26abfa225e7d92ca3f","id":"huggingface_hub.inference._generated.types.video_classification","ignore_all":true,"interface_hash":"49c8b82cd31cc3bb0faf938185f399b6a8ac2f00","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/video_classification.py","plugin_data":null,"size":1680,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/visual_question_answering.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/visual_question_answering.data.json new file mode 100644 index 0000000000000000000000000000000000000000..32a5834845c12c227d482e49e329e2a2295d171f --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/visual_question_answering.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._generated.types.visual_question_answering","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseInferenceType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.BaseInferenceType","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"VisualQuestionAnsweringInput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringInput","name":"VisualQuestionAnsweringInput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringInput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.visual_question_answering","mro":["huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringInput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","inputs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringInput.inputs","name":"inputs","setter_type":null,"type":"huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringInputData"}},"parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringInput.parameters","name":"parameters","setter_type":null,"type":{".class":"UnionType","items":["huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringInput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringInput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"VisualQuestionAnsweringInputData":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringInputData","name":"VisualQuestionAnsweringInputData","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringInputData","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.visual_question_answering","mro":["huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringInputData","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","image":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringInputData.image","name":"image","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"question":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringInputData.question","name":"question","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringInputData.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringInputData","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"VisualQuestionAnsweringOutputElement":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringOutputElement","name":"VisualQuestionAnsweringOutputElement","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringOutputElement","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.visual_question_answering","mro":["huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringOutputElement","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","answer":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringOutputElement.answer","name":"answer","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"score":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringOutputElement.score","name":"score","setter_type":null,"type":"builtins.float"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringOutputElement.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringOutputElement","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"VisualQuestionAnsweringParameters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringParameters","name":"VisualQuestionAnsweringParameters","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringParameters","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.visual_question_answering","mro":["huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringParameters","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","top_k":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringParameters.top_k","name":"top_k","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringParameters.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.visual_question_answering.VisualQuestionAnsweringParameters","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.visual_question_answering.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.visual_question_answering.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.visual_question_answering.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.visual_question_answering.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.visual_question_answering.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.visual_question_answering.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"dataclass_with_extra":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.dataclass_with_extra","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/visual_question_answering.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/visual_question_answering.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/visual_question_answering.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..994bab7a4f1d021b62a6486dcbd268b4616a30a7 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/visual_question_answering.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[8,6,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["huggingface_hub.inference._generated.types.base","typing","builtins","_frozen_importlib","_typeshed","abc"],"hash":"da7cb3d4cc641c17ab2c2ae4606eb4f41ef93022","id":"huggingface_hub.inference._generated.types.visual_question_answering","ignore_all":true,"interface_hash":"5fdef64f47409fe16895a0bd8cb12e9adfbc8e12","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/visual_question_answering.py","plugin_data":null,"size":1673,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/zero_shot_classification.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/zero_shot_classification.data.json new file mode 100644 index 0000000000000000000000000000000000000000..91e93fa905d25ce5d0b145783da5ad14e87a3dde --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/zero_shot_classification.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._generated.types.zero_shot_classification","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","BaseInferenceType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.BaseInferenceType","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"ZeroShotClassificationInput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.zero_shot_classification.ZeroShotClassificationInput","name":"ZeroShotClassificationInput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.zero_shot_classification.ZeroShotClassificationInput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.zero_shot_classification","mro":["huggingface_hub.inference._generated.types.zero_shot_classification.ZeroShotClassificationInput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","inputs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_classification.ZeroShotClassificationInput.inputs","name":"inputs","setter_type":null,"type":"builtins.str"}},"parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_classification.ZeroShotClassificationInput.parameters","name":"parameters","setter_type":null,"type":"huggingface_hub.inference._generated.types.zero_shot_classification.ZeroShotClassificationParameters"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.zero_shot_classification.ZeroShotClassificationInput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.zero_shot_classification.ZeroShotClassificationInput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ZeroShotClassificationOutputElement":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.zero_shot_classification.ZeroShotClassificationOutputElement","name":"ZeroShotClassificationOutputElement","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.zero_shot_classification.ZeroShotClassificationOutputElement","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.zero_shot_classification","mro":["huggingface_hub.inference._generated.types.zero_shot_classification.ZeroShotClassificationOutputElement","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","label":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_classification.ZeroShotClassificationOutputElement.label","name":"label","setter_type":null,"type":"builtins.str"}},"score":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_classification.ZeroShotClassificationOutputElement.score","name":"score","setter_type":null,"type":"builtins.float"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.zero_shot_classification.ZeroShotClassificationOutputElement.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.zero_shot_classification.ZeroShotClassificationOutputElement","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ZeroShotClassificationParameters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.zero_shot_classification.ZeroShotClassificationParameters","name":"ZeroShotClassificationParameters","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.zero_shot_classification.ZeroShotClassificationParameters","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.zero_shot_classification","mro":["huggingface_hub.inference._generated.types.zero_shot_classification.ZeroShotClassificationParameters","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","candidate_labels":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_classification.ZeroShotClassificationParameters.candidate_labels","name":"candidate_labels","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"hypothesis_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_classification.ZeroShotClassificationParameters.hypothesis_template","name":"hypothesis_template","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"multi_label":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_classification.ZeroShotClassificationParameters.multi_label","name":"multi_label","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.zero_shot_classification.ZeroShotClassificationParameters.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.zero_shot_classification.ZeroShotClassificationParameters","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_classification.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_classification.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_classification.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_classification.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_classification.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_classification.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"dataclass_with_extra":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.dataclass_with_extra","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/zero_shot_classification.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/zero_shot_classification.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/zero_shot_classification.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..4a633a5807a252847d6a230cb2218cd7a4706036 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/zero_shot_classification.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[8,6,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["huggingface_hub.inference._generated.types.base","typing","builtins","_frozen_importlib","_typeshed","abc"],"hash":"468b48207dddf5a3fd96d513cb5d5b6b53a86ac5","id":"huggingface_hub.inference._generated.types.zero_shot_classification","ignore_all":true,"interface_hash":"22c14888b59707020d41afba4fe278ddf75bc3cb","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/zero_shot_classification.py","plugin_data":null,"size":1732,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/zero_shot_image_classification.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/zero_shot_image_classification.data.json new file mode 100644 index 0000000000000000000000000000000000000000..7fa9cccd32c87179fa4b4e554ca11763a2346ddc --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/zero_shot_image_classification.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._generated.types.zero_shot_image_classification","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","BaseInferenceType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.BaseInferenceType","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"ZeroShotImageClassificationInput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.zero_shot_image_classification.ZeroShotImageClassificationInput","name":"ZeroShotImageClassificationInput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.zero_shot_image_classification.ZeroShotImageClassificationInput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.zero_shot_image_classification","mro":["huggingface_hub.inference._generated.types.zero_shot_image_classification.ZeroShotImageClassificationInput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","inputs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_image_classification.ZeroShotImageClassificationInput.inputs","name":"inputs","setter_type":null,"type":"builtins.str"}},"parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_image_classification.ZeroShotImageClassificationInput.parameters","name":"parameters","setter_type":null,"type":"huggingface_hub.inference._generated.types.zero_shot_image_classification.ZeroShotImageClassificationParameters"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.zero_shot_image_classification.ZeroShotImageClassificationInput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.zero_shot_image_classification.ZeroShotImageClassificationInput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ZeroShotImageClassificationOutputElement":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.zero_shot_image_classification.ZeroShotImageClassificationOutputElement","name":"ZeroShotImageClassificationOutputElement","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.zero_shot_image_classification.ZeroShotImageClassificationOutputElement","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.zero_shot_image_classification","mro":["huggingface_hub.inference._generated.types.zero_shot_image_classification.ZeroShotImageClassificationOutputElement","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","label":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_image_classification.ZeroShotImageClassificationOutputElement.label","name":"label","setter_type":null,"type":"builtins.str"}},"score":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_image_classification.ZeroShotImageClassificationOutputElement.score","name":"score","setter_type":null,"type":"builtins.float"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.zero_shot_image_classification.ZeroShotImageClassificationOutputElement.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.zero_shot_image_classification.ZeroShotImageClassificationOutputElement","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ZeroShotImageClassificationParameters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.zero_shot_image_classification.ZeroShotImageClassificationParameters","name":"ZeroShotImageClassificationParameters","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.zero_shot_image_classification.ZeroShotImageClassificationParameters","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.zero_shot_image_classification","mro":["huggingface_hub.inference._generated.types.zero_shot_image_classification.ZeroShotImageClassificationParameters","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","candidate_labels":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_image_classification.ZeroShotImageClassificationParameters.candidate_labels","name":"candidate_labels","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"hypothesis_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_image_classification.ZeroShotImageClassificationParameters.hypothesis_template","name":"hypothesis_template","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.zero_shot_image_classification.ZeroShotImageClassificationParameters.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.zero_shot_image_classification.ZeroShotImageClassificationParameters","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_image_classification.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_image_classification.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_image_classification.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_image_classification.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_image_classification.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_image_classification.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"dataclass_with_extra":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.dataclass_with_extra","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/zero_shot_image_classification.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/zero_shot_image_classification.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/zero_shot_image_classification.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..e584c9caa870131b9355eeb682a94aef3da0b85f --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/zero_shot_image_classification.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[8,6,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["huggingface_hub.inference._generated.types.base","typing","builtins","_frozen_importlib","_typeshed","abc"],"hash":"cec398e777b24723ed2aac9f6542ae030c9ce515","id":"huggingface_hub.inference._generated.types.zero_shot_image_classification","ignore_all":true,"interface_hash":"7bea4c2d880eb3748f6fadfc21612fccb8e9e559","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/zero_shot_image_classification.py","plugin_data":null,"size":1481,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/zero_shot_object_detection.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/zero_shot_object_detection.data.json new file mode 100644 index 0000000000000000000000000000000000000000..541ccb62e490780d67cfbe5138489dda6b1cdcaf --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/zero_shot_object_detection.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._generated.types.zero_shot_object_detection","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","BaseInferenceType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.BaseInferenceType","kind":"Gdef"},"ZeroShotObjectDetectionBoundingBox":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.zero_shot_object_detection.ZeroShotObjectDetectionBoundingBox","name":"ZeroShotObjectDetectionBoundingBox","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.zero_shot_object_detection.ZeroShotObjectDetectionBoundingBox","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.zero_shot_object_detection","mro":["huggingface_hub.inference._generated.types.zero_shot_object_detection.ZeroShotObjectDetectionBoundingBox","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","xmax":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_object_detection.ZeroShotObjectDetectionBoundingBox.xmax","name":"xmax","setter_type":null,"type":"builtins.int"}},"xmin":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_object_detection.ZeroShotObjectDetectionBoundingBox.xmin","name":"xmin","setter_type":null,"type":"builtins.int"}},"ymax":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_object_detection.ZeroShotObjectDetectionBoundingBox.ymax","name":"ymax","setter_type":null,"type":"builtins.int"}},"ymin":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_object_detection.ZeroShotObjectDetectionBoundingBox.ymin","name":"ymin","setter_type":null,"type":"builtins.int"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.zero_shot_object_detection.ZeroShotObjectDetectionBoundingBox.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.zero_shot_object_detection.ZeroShotObjectDetectionBoundingBox","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ZeroShotObjectDetectionInput":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.zero_shot_object_detection.ZeroShotObjectDetectionInput","name":"ZeroShotObjectDetectionInput","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.zero_shot_object_detection.ZeroShotObjectDetectionInput","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.zero_shot_object_detection","mro":["huggingface_hub.inference._generated.types.zero_shot_object_detection.ZeroShotObjectDetectionInput","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","inputs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_object_detection.ZeroShotObjectDetectionInput.inputs","name":"inputs","setter_type":null,"type":"builtins.str"}},"parameters":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_object_detection.ZeroShotObjectDetectionInput.parameters","name":"parameters","setter_type":null,"type":"huggingface_hub.inference._generated.types.zero_shot_object_detection.ZeroShotObjectDetectionParameters"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.zero_shot_object_detection.ZeroShotObjectDetectionInput.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.zero_shot_object_detection.ZeroShotObjectDetectionInput","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ZeroShotObjectDetectionOutputElement":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.zero_shot_object_detection.ZeroShotObjectDetectionOutputElement","name":"ZeroShotObjectDetectionOutputElement","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.zero_shot_object_detection.ZeroShotObjectDetectionOutputElement","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.zero_shot_object_detection","mro":["huggingface_hub.inference._generated.types.zero_shot_object_detection.ZeroShotObjectDetectionOutputElement","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","box":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_object_detection.ZeroShotObjectDetectionOutputElement.box","name":"box","setter_type":null,"type":"huggingface_hub.inference._generated.types.zero_shot_object_detection.ZeroShotObjectDetectionBoundingBox"}},"label":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_object_detection.ZeroShotObjectDetectionOutputElement.label","name":"label","setter_type":null,"type":"builtins.str"}},"score":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_object_detection.ZeroShotObjectDetectionOutputElement.score","name":"score","setter_type":null,"type":"builtins.float"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.zero_shot_object_detection.ZeroShotObjectDetectionOutputElement.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.zero_shot_object_detection.ZeroShotObjectDetectionOutputElement","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ZeroShotObjectDetectionParameters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._generated.types.base.BaseInferenceType"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._generated.types.zero_shot_object_detection.ZeroShotObjectDetectionParameters","name":"ZeroShotObjectDetectionParameters","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._generated.types.zero_shot_object_detection.ZeroShotObjectDetectionParameters","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._generated.types.zero_shot_object_detection","mro":["huggingface_hub.inference._generated.types.zero_shot_object_detection.ZeroShotObjectDetectionParameters","huggingface_hub.inference._generated.types.base.BaseInferenceType","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","candidate_labels":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_object_detection.ZeroShotObjectDetectionParameters.candidate_labels","name":"candidate_labels","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._generated.types.zero_shot_object_detection.ZeroShotObjectDetectionParameters.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._generated.types.zero_shot_object_detection.ZeroShotObjectDetectionParameters","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_object_detection.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_object_detection.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_object_detection.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_object_detection.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_object_detection.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._generated.types.zero_shot_object_detection.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"dataclass_with_extra":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.base.dataclass_with_extra","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/zero_shot_object_detection.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/zero_shot_object_detection.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/zero_shot_object_detection.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..d07b93993b15df697c5e0fad6cf675356dd44ec6 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_generated/types/zero_shot_object_detection.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[6,1,1,1,1,1],"dep_prios":[5,5,30,30,30,30],"dependencies":["huggingface_hub.inference._generated.types.base","builtins","_frozen_importlib","_typeshed","abc","typing"],"hash":"e804b086c5c617caf4738de1818d925471903d68","id":"huggingface_hub.inference._generated.types.zero_shot_object_detection","ignore_all":true,"interface_hash":"02e9276ad93c4095eab0af296bd5283bd6bb1009","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_generated/types/zero_shot_object_detection.py","plugin_data":null,"size":1605,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_mcp/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_mcp/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..f94f1a40812805330ef70af7738d86647bf8fc94 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_mcp/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._mcp","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_mcp/__init__.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_mcp/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_mcp/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..d113f347c20ae06ffae7f09ee76b20998e4ccb78 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_mcp/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106714,"dep_lines":[1,1,1,1],"dep_prios":[5,30,30,30],"dependencies":["builtins","_frozen_importlib","abc","typing"],"hash":"da39a3ee5e6b4b0d3255bfef95601890afd80709","id":"huggingface_hub.inference._mcp","ignore_all":true,"interface_hash":"96c4196f1cbba15613a4a62625da9ddcb3f5a689","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_mcp/__init__.py","plugin_data":null,"size":0,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_mcp/agent.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_mcp/agent.data.json new file mode 100644 index 0000000000000000000000000000000000000000..edffb3988eded3f15e035b3d367117c3d49dc548 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_mcp/agent.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._mcp.agent","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Agent":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._mcp.mcp_client.MCPClient"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._mcp.agent.Agent","name":"Agent","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._mcp.agent.Agent","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._mcp.agent","mro":["huggingface_hub.inference._mcp.agent.Agent","huggingface_hub.inference._mcp.mcp_client.MCPClient","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,3,5,5,5,5],"arg_names":["self","model","servers","provider","base_url","api_key","prompt"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._mcp.agent.Agent.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,3,5,5,5,5],"arg_names":["self","model","servers","provider","base_url","api_key","prompt"],"arg_types":["huggingface_hub.inference._mcp.agent.Agent",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._mcp.types.ServerConfig"}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._providers.PROVIDER_OR_POLICY_T"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of Agent","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_servers_cfg":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._mcp.agent.Agent._servers_cfg","name":"_servers_cfg","setter_type":null,"type":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._mcp.types.StdioServerConfig"},{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._mcp.types.HTTPServerConfig"},{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._mcp.types.SSEServerConfig"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"}}},"load_tools":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"huggingface_hub.inference._mcp.agent.Agent.load_tools","name":"load_tools","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.inference._mcp.agent.Agent"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"load_tools of Agent","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"messages":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"huggingface_hub.inference._mcp.agent.Agent.messages","name":"messages","setter_type":null,"type":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"}}},"run":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5],"arg_names":["self","user_input","abort_event"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_generator","is_coroutine","is_async_generator","is_trivial_self"],"fullname":"huggingface_hub.inference._mcp.agent.Agent.run","name":"run","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["self","user_input","abort_event"],"arg_types":["huggingface_hub.inference._mcp.agent.Agent","builtins.str",{".class":"UnionType","items":["asyncio.locks.Event",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"run of Agent","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutput","huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage"],"uses_pep604_syntax":false},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.AsyncGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._mcp.agent.Agent.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._mcp.agent.Agent","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"AsyncGenerator":{".class":"SymbolTableNode","cross_ref":"typing.AsyncGenerator","kind":"Gdef"},"ChatCompletionInputMessage":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage","kind":"Gdef"},"ChatCompletionStreamOutput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutput","kind":"Gdef"},"DEFAULT_SYSTEM_PROMPT":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._mcp.constants.DEFAULT_SYSTEM_PROMPT","kind":"Gdef"},"EXIT_LOOP_TOOLS":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._mcp.constants.EXIT_LOOP_TOOLS","kind":"Gdef"},"Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef"},"MAX_NUM_TURNS":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._mcp.constants.MAX_NUM_TURNS","kind":"Gdef"},"MCPClient":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._mcp.mcp_client.MCPClient","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"PROVIDER_OR_POLICY_T":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.PROVIDER_OR_POLICY_T","kind":"Gdef"},"ServerConfig":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._mcp.types.ServerConfig","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.agent.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.agent.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.agent.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.agent.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.agent.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.agent.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"asyncio":{".class":"SymbolTableNode","cross_ref":"asyncio","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_mcp/agent.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_mcp/agent.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_mcp/agent.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..5f335940963369d72c4368eeb8c7a44312f6064b --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_mcp/agent.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[9,10,8,1,3,4,6,1,1,1,1,1,1,1,1,1],"dep_prios":[5,5,5,5,10,5,5,5,30,30,30,30,30,30,30,30],"dependencies":["huggingface_hub.inference._mcp.constants","huggingface_hub.inference._mcp.types","huggingface_hub.inference._providers","__future__","asyncio","typing","huggingface_hub","builtins","_frozen_importlib","abc","asyncio.locks","huggingface_hub.inference._generated","huggingface_hub.inference._generated.types","huggingface_hub.inference._generated.types.base","huggingface_hub.inference._generated.types.chat_completion","huggingface_hub.inference._mcp.mcp_client"],"hash":"126da4e9ac579ca9532c0946884b2f20a48ed690","id":"huggingface_hub.inference._mcp.agent","ignore_all":true,"interface_hash":"fc9549690b0bf003bdbd8c4b00f89208656bba79","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_mcp/agent.py","plugin_data":null,"size":4250,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_mcp/constants.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_mcp/constants.data.json new file mode 100644 index 0000000000000000000000000000000000000000..4fa1dea37f7aa5749792ed1f699e9d17b5a406f4 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_mcp/constants.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._mcp.constants","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","ASK_QUESTION_TOOL":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._mcp.constants.ASK_QUESTION_TOOL","name":"ASK_QUESTION_TOOL","setter_type":null,"type":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool"}},"ChatCompletionInputTool":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool","kind":"Gdef"},"DEFAULT_AGENT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.inference._mcp.constants.DEFAULT_AGENT","name":"DEFAULT_AGENT","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Collection"}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"DEFAULT_REPO_ID":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.inference._mcp.constants.DEFAULT_REPO_ID","name":"DEFAULT_REPO_ID","setter_type":null,"type":"builtins.str"}},"DEFAULT_SYSTEM_PROMPT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.inference._mcp.constants.DEFAULT_SYSTEM_PROMPT","name":"DEFAULT_SYSTEM_PROMPT","setter_type":null,"type":"builtins.str"}},"EXIT_LOOP_TOOLS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._mcp.constants.EXIT_LOOP_TOOLS","name":"EXIT_LOOP_TOOLS","setter_type":null,"type":{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool"],"extra_attrs":null,"type_ref":"builtins.list"}}},"FILENAME_CONFIG":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.inference._mcp.constants.FILENAME_CONFIG","name":"FILENAME_CONFIG","setter_type":null,"type":"builtins.str"}},"MAX_NUM_TURNS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.inference._mcp.constants.MAX_NUM_TURNS","name":"MAX_NUM_TURNS","setter_type":null,"type":"builtins.int"}},"PROMPT_FILENAMES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.inference._mcp.constants.PROMPT_FILENAMES","name":"PROMPT_FILENAMES","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"Path":{".class":"SymbolTableNode","cross_ref":"pathlib.Path","kind":"Gdef"},"TASK_COMPLETE_TOOL":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._mcp.constants.TASK_COMPLETE_TOOL","name":"TASK_COMPLETE_TOOL","setter_type":null,"type":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool"}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.constants.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.constants.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.constants.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.constants.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.constants.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.constants.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"sys":{".class":"SymbolTableNode","cross_ref":"sys","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_mcp/constants.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_mcp/constants.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_mcp/constants.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..162b9b1115df7085bd5936e704b5fdf29279d70f --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_mcp/constants.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[1,3,4,6,1,1,1,1,1,1,1,1,1,1,1],"dep_prios":[5,10,5,5,5,30,30,30,30,30,30,30,30,30,30],"dependencies":["__future__","sys","pathlib","huggingface_hub","builtins","_frozen_importlib","_typeshed","abc","huggingface_hub.inference._generated","huggingface_hub.inference._generated.types","huggingface_hub.inference._generated.types.base","huggingface_hub.inference._generated.types.chat_completion","os","typing","typing_extensions"],"hash":"25fecc7cee9359ca6866b32927d26eab686f10c7","id":"huggingface_hub.inference._mcp.constants","ignore_all":true,"interface_hash":"ee542c012c7dffae4849295b0110a90ead310371","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_mcp/constants.py","plugin_data":null,"size":2487,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_mcp/mcp_client.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_mcp/mcp_client.data.json new file mode 100644 index 0000000000000000000000000000000000000000..c8ef655f7461918682b7fad749b2647696f93e6d --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_mcp/mcp_client.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._mcp.mcp_client","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"AsyncExitStack":{".class":"SymbolTableNode","cross_ref":"contextlib.AsyncExitStack","kind":"Gdef"},"AsyncInferenceClient":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient","kind":"Gdef"},"AsyncIterable":{".class":"SymbolTableNode","cross_ref":"typing.AsyncIterable","kind":"Gdef"},"ChatCompletionInputMessage":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage","kind":"Gdef"},"ChatCompletionInputTool":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool","kind":"Gdef"},"ChatCompletionStreamOutput":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutput","kind":"Gdef"},"ChatCompletionStreamOutputDeltaToolCall":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutputDeltaToolCall","kind":"Gdef"},"ClientSession":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"huggingface_hub.inference._mcp.mcp_client.ClientSession","name":"ClientSession","setter_type":null,"type":{".class":"AnyType","missing_import_name":"huggingface_hub.inference._mcp.mcp_client.ClientSession","source_any":null,"type_of_any":3}}},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"MCPClient":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._mcp.mcp_client.MCPClient","name":"MCPClient","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._mcp.mcp_client.MCPClient","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._mcp.mcp_client","mro":["huggingface_hub.inference._mcp.mcp_client.MCPClient","builtins.object"],"names":{".class":"SymbolTable","__aenter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine"],"fullname":"huggingface_hub.inference._mcp.mcp_client.MCPClient.__aenter__","name":"__aenter__","original_first_arg":"self","type":null}},"__aexit__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","exc_type","exc_val","exc_tb"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine"],"fullname":"huggingface_hub.inference._mcp.mcp_client.MCPClient.__aexit__","name":"__aexit__","original_first_arg":"self","type":null}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5],"arg_names":["self","model","provider","base_url","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._mcp.mcp_client.MCPClient.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":["self","model","provider","base_url","api_key"],"arg_types":["huggingface_hub.inference._mcp.mcp_client.MCPClient",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._providers.PROVIDER_OR_POLICY_T"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of MCPClient","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"add_mcp_server":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._mcp.mcp_client.MCPClient.add_mcp_server","impl":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,4],"arg_names":["self","type","params"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_coroutine","is_trivial_self"],"fullname":"huggingface_hub.inference._mcp.mcp_client.MCPClient.add_mcp_server","name":"add_mcp_server","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,4],"arg_names":["self","type","params"],"arg_types":["huggingface_hub.inference._mcp.mcp_client.MCPClient",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._mcp.mcp_client.ServerType"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add_mcp_server of MCPClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,4],"arg_names":["self","type","params"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_coroutine","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.inference._mcp.mcp_client.MCPClient.add_mcp_server","name":"add_mcp_server","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,4],"arg_names":["self","type","params"],"arg_types":["huggingface_hub.inference._mcp.mcp_client.MCPClient",{".class":"LiteralType","fallback":"builtins.str","value":"stdio"},{".class":"TypedDictType","fallback":"huggingface_hub.inference._mcp.mcp_client.StdioServerParameters_T","items":[["command","builtins.str"],["args",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],["env",{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}],["cwd",{".class":"UnionType","items":["builtins.str","pathlib.Path",{".class":"NoneType"}],"uses_pep604_syntax":false}]],"readonly_keys":[],"required_keys":["command"]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add_mcp_server of MCPClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":true,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._mcp.mcp_client.MCPClient.add_mcp_server","name":"add_mcp_server","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,4],"arg_names":["self","type","params"],"arg_types":["huggingface_hub.inference._mcp.mcp_client.MCPClient",{".class":"LiteralType","fallback":"builtins.str","value":"stdio"},{".class":"TypedDictType","fallback":"huggingface_hub.inference._mcp.mcp_client.StdioServerParameters_T","items":[["command","builtins.str"],["args",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],["env",{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}],["cwd",{".class":"UnionType","items":["builtins.str","pathlib.Path",{".class":"NoneType"}],"uses_pep604_syntax":false}]],"readonly_keys":[],"required_keys":["command"]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add_mcp_server of MCPClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":true,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,4],"arg_names":["self","type","params"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_coroutine","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.inference._mcp.mcp_client.MCPClient.add_mcp_server","name":"add_mcp_server","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,4],"arg_names":["self","type","params"],"arg_types":["huggingface_hub.inference._mcp.mcp_client.MCPClient",{".class":"LiteralType","fallback":"builtins.str","value":"sse"},{".class":"TypedDictType","fallback":"huggingface_hub.inference._mcp.mcp_client.SSEServerParameters_T","items":[["url","builtins.str"],["headers",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],["timeout","builtins.float"],["sse_read_timeout","builtins.float"]],"readonly_keys":[],"required_keys":["url"]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add_mcp_server of MCPClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":true,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._mcp.mcp_client.MCPClient.add_mcp_server","name":"add_mcp_server","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,4],"arg_names":["self","type","params"],"arg_types":["huggingface_hub.inference._mcp.mcp_client.MCPClient",{".class":"LiteralType","fallback":"builtins.str","value":"sse"},{".class":"TypedDictType","fallback":"huggingface_hub.inference._mcp.mcp_client.SSEServerParameters_T","items":[["url","builtins.str"],["headers",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],["timeout","builtins.float"],["sse_read_timeout","builtins.float"]],"readonly_keys":[],"required_keys":["url"]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add_mcp_server of MCPClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":true,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,4],"arg_names":["self","type","params"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_coroutine","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.inference._mcp.mcp_client.MCPClient.add_mcp_server","name":"add_mcp_server","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,4],"arg_names":["self","type","params"],"arg_types":["huggingface_hub.inference._mcp.mcp_client.MCPClient",{".class":"LiteralType","fallback":"builtins.str","value":"http"},{".class":"TypedDictType","fallback":"huggingface_hub.inference._mcp.mcp_client.StreamableHTTPParameters_T","items":[["url","builtins.str"],["headers",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],["timeout","datetime.timedelta"],["sse_read_timeout","datetime.timedelta"],["terminate_on_close","builtins.bool"]],"readonly_keys":[],"required_keys":["url"]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add_mcp_server of MCPClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":true,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._mcp.mcp_client.MCPClient.add_mcp_server","name":"add_mcp_server","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,4],"arg_names":["self","type","params"],"arg_types":["huggingface_hub.inference._mcp.mcp_client.MCPClient",{".class":"LiteralType","fallback":"builtins.str","value":"http"},{".class":"TypedDictType","fallback":"huggingface_hub.inference._mcp.mcp_client.StreamableHTTPParameters_T","items":[["url","builtins.str"],["headers",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],["timeout","datetime.timedelta"],["sse_read_timeout","datetime.timedelta"],["terminate_on_close","builtins.bool"]],"readonly_keys":[],"required_keys":["url"]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add_mcp_server of MCPClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":true,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,4],"arg_names":["self","type","params"],"arg_types":["huggingface_hub.inference._mcp.mcp_client.MCPClient",{".class":"LiteralType","fallback":"builtins.str","value":"stdio"},{".class":"TypedDictType","fallback":"huggingface_hub.inference._mcp.mcp_client.StdioServerParameters_T","items":[["command","builtins.str"],["args",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],["env",{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}],["cwd",{".class":"UnionType","items":["builtins.str","pathlib.Path",{".class":"NoneType"}],"uses_pep604_syntax":false}]],"readonly_keys":[],"required_keys":["command"]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add_mcp_server of MCPClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":true,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,4],"arg_names":["self","type","params"],"arg_types":["huggingface_hub.inference._mcp.mcp_client.MCPClient",{".class":"LiteralType","fallback":"builtins.str","value":"sse"},{".class":"TypedDictType","fallback":"huggingface_hub.inference._mcp.mcp_client.SSEServerParameters_T","items":[["url","builtins.str"],["headers",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],["timeout","builtins.float"],["sse_read_timeout","builtins.float"]],"readonly_keys":[],"required_keys":["url"]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add_mcp_server of MCPClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":true,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,4],"arg_names":["self","type","params"],"arg_types":["huggingface_hub.inference._mcp.mcp_client.MCPClient",{".class":"LiteralType","fallback":"builtins.str","value":"http"},{".class":"TypedDictType","fallback":"huggingface_hub.inference._mcp.mcp_client.StreamableHTTPParameters_T","items":[["url","builtins.str"],["headers",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],["timeout","datetime.timedelta"],["sse_read_timeout","datetime.timedelta"],["terminate_on_close","builtins.bool"]],"readonly_keys":[],"required_keys":["url"]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add_mcp_server of MCPClient","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":true,"variables":[]}]}}},"available_tools":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"huggingface_hub.inference._mcp.mcp_client.MCPClient.available_tools","name":"available_tools","setter_type":null,"type":{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool"],"extra_attrs":null,"type_ref":"builtins.list"}}},"cleanup":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine"],"fullname":"huggingface_hub.inference._mcp.mcp_client.MCPClient.cleanup","name":"cleanup","original_first_arg":"self","type":null}},"client":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._mcp.mcp_client.MCPClient.client","name":"client","setter_type":null,"type":"huggingface_hub.inference._generated._async_client.AsyncInferenceClient"}},"exit_stack":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._mcp.mcp_client.MCPClient.exit_stack","name":"exit_stack","setter_type":null,"type":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"contextlib.AsyncExitStack"}}},"payload_model":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._mcp.mcp_client.MCPClient.payload_model","name":"payload_model","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"process_single_turn_with_tools":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","messages","exit_loop_tools","exit_if_first_chunk_no_tool"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_generator","is_coroutine","is_async_generator","is_trivial_self"],"fullname":"huggingface_hub.inference._mcp.mcp_client.MCPClient.process_single_turn_with_tools","name":"process_single_turn_with_tools","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","messages","exit_loop_tools","exit_if_first_chunk_no_tool"],"arg_types":["huggingface_hub.inference._mcp.mcp_client.MCPClient",{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"UnionType","items":[{".class":"Instance","args":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"process_single_turn_with_tools of MCPClient","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["huggingface_hub.inference._generated.types.chat_completion.ChatCompletionStreamOutput","huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"typing.AsyncIterable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"sessions":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"huggingface_hub.inference._mcp.mcp_client.MCPClient.sessions","name":"sessions","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":"huggingface_hub.inference._mcp.mcp_client.ClientSession","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.dict"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._mcp.mcp_client.MCPClient.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._mcp.mcp_client.MCPClient","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"NotRequired":{".class":"SymbolTableNode","cross_ref":"typing_extensions.NotRequired","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"PROVIDER_OR_POLICY_T":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.PROVIDER_OR_POLICY_T","kind":"Gdef"},"Path":{".class":"SymbolTableNode","cross_ref":"pathlib.Path","kind":"Gdef"},"SSEServerParameters_T":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._mcp.mcp_client.SSEServerParameters_T","name":"SSEServerParameters_T","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._mcp.mcp_client.SSEServerParameters_T","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._mcp.mcp_client","mro":["huggingface_hub.inference._mcp.mcp_client.SSEServerParameters_T","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["url","builtins.str"],["headers",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],["timeout","builtins.float"],["sse_read_timeout","builtins.float"]],"readonly_keys":[],"required_keys":["url"]}}},"ServerType":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.inference._mcp.mcp_client.ServerType","line":30,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"stdio"},{".class":"LiteralType","fallback":"builtins.str","value":"sse"},{".class":"LiteralType","fallback":"builtins.str","value":"http"}],"uses_pep604_syntax":false}}},"StdioServerParameters_T":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._mcp.mcp_client.StdioServerParameters_T","name":"StdioServerParameters_T","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._mcp.mcp_client.StdioServerParameters_T","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._mcp.mcp_client","mro":["huggingface_hub.inference._mcp.mcp_client.StdioServerParameters_T","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["command","builtins.str"],["args",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],["env",{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}],["cwd",{".class":"UnionType","items":["builtins.str","pathlib.Path",{".class":"NoneType"}],"uses_pep604_syntax":false}]],"readonly_keys":[],"required_keys":["command"]}}},"StreamableHTTPParameters_T":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._mcp.mcp_client.StreamableHTTPParameters_T","name":"StreamableHTTPParameters_T","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._mcp.mcp_client.StreamableHTTPParameters_T","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._mcp.mcp_client","mro":["huggingface_hub.inference._mcp.mcp_client.StreamableHTTPParameters_T","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["url","builtins.str"],["headers",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],["timeout","datetime.timedelta"],["sse_read_timeout","datetime.timedelta"],["terminate_on_close","builtins.bool"]],"readonly_keys":[],"required_keys":["url"]}}},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"ToolName":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.inference._mcp.mcp_client.ToolName","line":28,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":"builtins.str"}},"TypeAlias":{".class":"SymbolTableNode","cross_ref":"typing_extensions.TypeAlias","kind":"Gdef"},"TypedDict":{".class":"SymbolTableNode","cross_ref":"typing.TypedDict","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"Unpack":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Unpack","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.mcp_client.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.mcp_client.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.mcp_client.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.mcp_client.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.mcp_client.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.mcp_client.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"format_result":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._mcp.utils.format_result","kind":"Gdef"},"get_hf_hub_version":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.get_hf_hub_version","kind":"Gdef"},"json":{".class":"SymbolTableNode","cross_ref":"json","kind":"Gdef"},"logger":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.inference._mcp.mcp_client.logger","name":"logger","setter_type":null,"type":"logging.Logger"}},"logging":{".class":"SymbolTableNode","cross_ref":"logging","kind":"Gdef"},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef"},"timedelta":{".class":"SymbolTableNode","cross_ref":"datetime.timedelta","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_mcp/mcp_client.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_mcp/mcp_client.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_mcp/mcp_client.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..48850090aaa9acfba693ca9f5b6fee319c3be969 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_mcp/mcp_client.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[11,12,19,10,18,1,2,3,4,5,6,8,1,1,1,1,1,1,1,163,175,186,23],"dep_prios":[5,5,5,5,5,10,10,5,5,5,5,5,5,30,30,30,30,30,30,20,20,20,20],"dependencies":["huggingface_hub.inference._generated._async_client","huggingface_hub.inference._generated.types","huggingface_hub.inference._mcp.utils","huggingface_hub.utils._runtime","huggingface_hub.inference._providers","json","logging","contextlib","datetime","pathlib","typing","typing_extensions","builtins","_frozen_importlib","abc","huggingface_hub.inference._generated","huggingface_hub.inference._generated.types.base","huggingface_hub.inference._generated.types.chat_completion","os"],"hash":"217fb7b872b2960daf0c430554c3718a82f5ebbd","id":"huggingface_hub.inference._mcp.mcp_client","ignore_all":true,"interface_hash":"f74f33b8e85b0d2b4d8d119dd7a8f19cf8820c48","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_mcp/mcp_client.py","plugin_data":null,"size":17243,"suppressed":["mcp.client.stdio","mcp.client.sse","mcp.client.streamable_http","mcp"],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_mcp/types.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_mcp/types.data.json new file mode 100644 index 0000000000000000000000000000000000000000..de194b6bbe7610d7980ad8ba894bf6ee28e4cac6 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_mcp/types.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._mcp.types","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","AgentConfig":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._mcp.types.AgentConfig","name":"AgentConfig","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._mcp.types.AgentConfig","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._mcp.types","mro":["huggingface_hub.inference._mcp.types.AgentConfig","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["model","builtins.str"],["provider","builtins.str"],["apiKey","builtins.str"],["inputs",{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._mcp.types.InputConfig"}],"extra_attrs":null,"type_ref":"builtins.list"}],["servers",{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._mcp.types.ServerConfig"}],"extra_attrs":null,"type_ref":"builtins.list"}]],"readonly_keys":[],"required_keys":["inputs","model","provider","servers"]}}},"HTTPServerConfig":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._mcp.types.HTTPServerConfig","name":"HTTPServerConfig","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._mcp.types.HTTPServerConfig","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._mcp.types","mro":["huggingface_hub.inference._mcp.types.HTTPServerConfig","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["type",{".class":"LiteralType","fallback":"builtins.str","value":"http"}],["url","builtins.str"],["headers",{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}],["allowed_tools",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}]],"readonly_keys":[],"required_keys":["headers","type","url"]}}},"InputConfig":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._mcp.types.InputConfig","name":"InputConfig","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._mcp.types.InputConfig","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._mcp.types","mro":["huggingface_hub.inference._mcp.types.InputConfig","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["id","builtins.str"],["description","builtins.str"],["type","builtins.str"],["password","builtins.bool"]],"readonly_keys":[],"required_keys":[]}}},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"NotRequired":{".class":"SymbolTableNode","cross_ref":"typing_extensions.NotRequired","kind":"Gdef"},"SSEServerConfig":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._mcp.types.SSEServerConfig","name":"SSEServerConfig","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._mcp.types.SSEServerConfig","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._mcp.types","mro":["huggingface_hub.inference._mcp.types.SSEServerConfig","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["type",{".class":"LiteralType","fallback":"builtins.str","value":"sse"}],["url","builtins.str"],["headers",{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}],["allowed_tools",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}]],"readonly_keys":[],"required_keys":["headers","type","url"]}}},"ServerConfig":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.inference._mcp.types.ServerConfig","line":36,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._mcp.types.StdioServerConfig"},{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._mcp.types.HTTPServerConfig"},{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._mcp.types.SSEServerConfig"}],"uses_pep604_syntax":false}}},"StdioServerConfig":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._mcp.types.StdioServerConfig","name":"StdioServerConfig","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._mcp.types.StdioServerConfig","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._mcp.types","mro":["huggingface_hub.inference._mcp.types.StdioServerConfig","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["type",{".class":"LiteralType","fallback":"builtins.str","value":"stdio"}],["command","builtins.str"],["args",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],["env",{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}],["cwd","builtins.str"],["allowed_tools",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}]],"readonly_keys":[],"required_keys":["args","command","cwd","env","type"]}}},"TypedDict":{".class":"SymbolTableNode","cross_ref":"typing.TypedDict","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.types.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.types.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.types.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.types.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.types.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.types.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_mcp/types.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_mcp/types.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_mcp/types.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..6f10521755f37b640bd0bcaa309eaa0c30961f68 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_mcp/types.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106714,"dep_lines":[1,3,1,1,1],"dep_prios":[5,5,5,30,30],"dependencies":["typing","typing_extensions","builtins","_frozen_importlib","abc"],"hash":"6fe5dbc8a7b8ee2a05eede69f2c57a8f99044b5d","id":"huggingface_hub.inference._mcp.types","ignore_all":true,"interface_hash":"f5a9a2b6691948e035071372ceb2079cb9b9c66d","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_mcp/types.py","plugin_data":null,"size":929,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_mcp/utils.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_mcp/utils.data.json new file mode 100644 index 0000000000000000000000000000000000000000..5e9b46c5f8bd9f19d9509ec4ab4016eb6d944c94 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_mcp/utils.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._mcp.utils","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","AgentConfig":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._mcp.types.AgentConfig","kind":"Gdef"},"DEFAULT_AGENT":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._mcp.constants.DEFAULT_AGENT","kind":"Gdef"},"DEFAULT_REPO_ID":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._mcp.constants.DEFAULT_REPO_ID","kind":"Gdef"},"EntryNotFoundError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.EntryNotFoundError","kind":"Gdef"},"FILENAME_CONFIG":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._mcp.constants.FILENAME_CONFIG","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"PROMPT_FILENAMES":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._mcp.constants.PROMPT_FILENAMES","kind":"Gdef"},"Path":{".class":"SymbolTableNode","cross_ref":"pathlib.Path","kind":"Gdef"},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.utils.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.utils.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.utils.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.utils.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.utils.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._mcp.utils.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_get_base64_size":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["base64_str"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._mcp.utils._get_base64_size","name":"_get_base64_size","original_first_arg":"base64_str","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["base64_str"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_base64_size","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_load_agent_config":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["agent_path"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._mcp.utils._load_agent_config","name":"_load_agent_config","original_first_arg":"agent_path","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["agent_path"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_load_agent_config","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._mcp.types.AgentConfig"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"format_result":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["result"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._mcp.utils.format_result","name":"format_result","original_first_arg":"result","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["result"],"arg_types":[{".class":"AnyType","missing_import_name":"huggingface_hub.inference._mcp.utils.mcp_types","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"format_result","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"json":{".class":"SymbolTableNode","cross_ref":"json","kind":"Gdef"},"mcp_types":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"huggingface_hub.inference._mcp.utils.mcp_types","name":"mcp_types","setter_type":null,"type":{".class":"AnyType","missing_import_name":"huggingface_hub.inference._mcp.utils.mcp_types","source_any":null,"type_of_any":3}}},"snapshot_download":{".class":"SymbolTableNode","cross_ref":"huggingface_hub._snapshot_download.snapshot_download","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_mcp/utils.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_mcp/utils.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_mcp/utils.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..5519e56081bff1d30303e6d62e1a9a47465caa0d --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_mcp/utils.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[14,15,12,7,8,9,11,1,1,1,19],"dep_prios":[5,5,5,10,5,5,5,5,30,30,25],"dependencies":["huggingface_hub.inference._mcp.constants","huggingface_hub.inference._mcp.types","huggingface_hub.errors","json","pathlib","typing","huggingface_hub","builtins","_frozen_importlib","abc"],"hash":"b57028cd1114497d569642c87757fc3d2827290c","id":"huggingface_hub.inference._mcp.utils","ignore_all":true,"interface_hash":"ce0c2539c60679461ff256f9de7799093fb28099","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_mcp/utils.py","plugin_data":null,"size":4175,"suppressed":["mcp"],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..d14d7b26a68201485d518f651609bd5eb6f2342e --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._providers","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","AutoRouterConversationalTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.AutoRouterConversationalTask","kind":"Gdef"},"BlackForestLabsTextToImageTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.black_forest_labs.BlackForestLabsTextToImageTask","kind":"Gdef"},"CONVERSATIONAL_AUTO_ROUTER":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.inference._providers.CONVERSATIONAL_AUTO_ROUTER","name":"CONVERSATIONAL_AUTO_ROUTER","setter_type":null,"type":"huggingface_hub.inference._providers._common.AutoRouterConversationalTask"}},"CerebrasConversationalTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.cerebras.CerebrasConversationalTask","kind":"Gdef"},"ClarifaiConversationalTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.clarifai.ClarifaiConversationalTask","kind":"Gdef"},"CohereConversationalTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.cohere.CohereConversationalTask","kind":"Gdef"},"FalAIAutomaticSpeechRecognitionTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.fal_ai.FalAIAutomaticSpeechRecognitionTask","kind":"Gdef"},"FalAIImageSegmentationTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.fal_ai.FalAIImageSegmentationTask","kind":"Gdef"},"FalAIImageToImageTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.fal_ai.FalAIImageToImageTask","kind":"Gdef"},"FalAIImageToVideoTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.fal_ai.FalAIImageToVideoTask","kind":"Gdef"},"FalAITextToImageTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.fal_ai.FalAITextToImageTask","kind":"Gdef"},"FalAITextToSpeechTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.fal_ai.FalAITextToSpeechTask","kind":"Gdef"},"FalAITextToVideoTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.fal_ai.FalAITextToVideoTask","kind":"Gdef"},"FeatherlessConversationalTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.featherless_ai.FeatherlessConversationalTask","kind":"Gdef"},"FeatherlessTextGenerationTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.featherless_ai.FeatherlessTextGenerationTask","kind":"Gdef"},"FireworksAIConversationalTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.fireworks_ai.FireworksAIConversationalTask","kind":"Gdef"},"GroqConversationalTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.groq.GroqConversationalTask","kind":"Gdef"},"HFInferenceBinaryInputTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.hf_inference.HFInferenceBinaryInputTask","kind":"Gdef"},"HFInferenceConversational":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.hf_inference.HFInferenceConversational","kind":"Gdef"},"HFInferenceFeatureExtractionTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.hf_inference.HFInferenceFeatureExtractionTask","kind":"Gdef"},"HFInferenceTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.hf_inference.HFInferenceTask","kind":"Gdef"},"HyperbolicTextGenerationTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.hyperbolic.HyperbolicTextGenerationTask","kind":"Gdef"},"HyperbolicTextToImageTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.hyperbolic.HyperbolicTextToImageTask","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"NebiusConversationalTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.nebius.NebiusConversationalTask","kind":"Gdef"},"NebiusFeatureExtractionTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.nebius.NebiusFeatureExtractionTask","kind":"Gdef"},"NebiusTextGenerationTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.nebius.NebiusTextGenerationTask","kind":"Gdef"},"NebiusTextToImageTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.nebius.NebiusTextToImageTask","kind":"Gdef"},"NovitaConversationalTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.novita.NovitaConversationalTask","kind":"Gdef"},"NovitaTextGenerationTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.novita.NovitaTextGenerationTask","kind":"Gdef"},"NovitaTextToVideoTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.novita.NovitaTextToVideoTask","kind":"Gdef"},"NscaleConversationalTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.nscale.NscaleConversationalTask","kind":"Gdef"},"NscaleTextToImageTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.nscale.NscaleTextToImageTask","kind":"Gdef"},"OpenAIConversationalTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.openai.OpenAIConversationalTask","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"PROVIDERS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._providers.PROVIDERS","name":"PROVIDERS","setter_type":null,"type":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._providers.PROVIDER_T"},{".class":"Instance","args":["builtins.str","huggingface_hub.inference._providers._common.TaskProviderHelper"],"extra_attrs":null,"type_ref":"builtins.dict"}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"PROVIDER_OR_POLICY_T":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.inference._providers.PROVIDER_OR_POLICY_T","line":82,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._providers.PROVIDER_T"},{".class":"LiteralType","fallback":"builtins.str","value":"auto"}],"uses_pep604_syntax":false}}},"PROVIDER_T":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.inference._providers.PROVIDER_T","line":58,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"black-forest-labs"},{".class":"LiteralType","fallback":"builtins.str","value":"cerebras"},{".class":"LiteralType","fallback":"builtins.str","value":"clarifai"},{".class":"LiteralType","fallback":"builtins.str","value":"cohere"},{".class":"LiteralType","fallback":"builtins.str","value":"fal-ai"},{".class":"LiteralType","fallback":"builtins.str","value":"featherless-ai"},{".class":"LiteralType","fallback":"builtins.str","value":"fireworks-ai"},{".class":"LiteralType","fallback":"builtins.str","value":"groq"},{".class":"LiteralType","fallback":"builtins.str","value":"hf-inference"},{".class":"LiteralType","fallback":"builtins.str","value":"hyperbolic"},{".class":"LiteralType","fallback":"builtins.str","value":"nebius"},{".class":"LiteralType","fallback":"builtins.str","value":"novita"},{".class":"LiteralType","fallback":"builtins.str","value":"nscale"},{".class":"LiteralType","fallback":"builtins.str","value":"openai"},{".class":"LiteralType","fallback":"builtins.str","value":"publicai"},{".class":"LiteralType","fallback":"builtins.str","value":"replicate"},{".class":"LiteralType","fallback":"builtins.str","value":"sambanova"},{".class":"LiteralType","fallback":"builtins.str","value":"scaleway"},{".class":"LiteralType","fallback":"builtins.str","value":"together"},{".class":"LiteralType","fallback":"builtins.str","value":"wavespeed"},{".class":"LiteralType","fallback":"builtins.str","value":"zai-org"}],"uses_pep604_syntax":false}}},"PublicAIConversationalTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.publicai.PublicAIConversationalTask","kind":"Gdef"},"ReplicateImageToImageTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.replicate.ReplicateImageToImageTask","kind":"Gdef"},"ReplicateTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.replicate.ReplicateTask","kind":"Gdef"},"ReplicateTextToImageTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.replicate.ReplicateTextToImageTask","kind":"Gdef"},"ReplicateTextToSpeechTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.replicate.ReplicateTextToSpeechTask","kind":"Gdef"},"SambanovaConversationalTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.sambanova.SambanovaConversationalTask","kind":"Gdef"},"SambanovaFeatureExtractionTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.sambanova.SambanovaFeatureExtractionTask","kind":"Gdef"},"ScalewayConversationalTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.scaleway.ScalewayConversationalTask","kind":"Gdef"},"ScalewayFeatureExtractionTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.scaleway.ScalewayFeatureExtractionTask","kind":"Gdef"},"TaskProviderHelper":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.TaskProviderHelper","kind":"Gdef"},"TogetherConversationalTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.together.TogetherConversationalTask","kind":"Gdef"},"TogetherTextGenerationTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.together.TogetherTextGenerationTask","kind":"Gdef"},"TogetherTextToImageTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.together.TogetherTextToImageTask","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"WavespeedAIImageToImageTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.wavespeed.WavespeedAIImageToImageTask","kind":"Gdef"},"WavespeedAIImageToVideoTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.wavespeed.WavespeedAIImageToVideoTask","kind":"Gdef"},"WavespeedAITextToImageTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.wavespeed.WavespeedAITextToImageTask","kind":"Gdef"},"WavespeedAITextToVideoTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.wavespeed.WavespeedAITextToVideoTask","kind":"Gdef"},"ZaiConversationalTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers.zai_org.ZaiConversationalTask","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_fetch_inference_provider_mapping":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common._fetch_inference_provider_mapping","kind":"Gdef"},"get_provider_helper":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["provider","task","model"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.get_provider_helper","name":"get_provider_helper","original_first_arg":"provider","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["provider","task","model"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.inference._providers.PROVIDER_OR_POLICY_T"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_provider_helper","ret_type":"huggingface_hub.inference._providers._common.TaskProviderHelper","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"logger":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.inference._providers.logger","name":"logger","setter_type":null,"type":"logging.Logger"}},"logging":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils.logging","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/__init__.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..eb29eb0ea02495ddc050b6cb682d2442b43649e8 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[3,9,10,11,12,13,14,23,24,25,31,32,38,39,40,41,42,43,44,45,46,52,7,7,1,1,1,1,1],"dep_prios":[5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,10,20,5,5,30,30,30],"dependencies":["huggingface_hub.inference._providers.featherless_ai","huggingface_hub.inference._providers._common","huggingface_hub.inference._providers.black_forest_labs","huggingface_hub.inference._providers.cerebras","huggingface_hub.inference._providers.clarifai","huggingface_hub.inference._providers.cohere","huggingface_hub.inference._providers.fal_ai","huggingface_hub.inference._providers.fireworks_ai","huggingface_hub.inference._providers.groq","huggingface_hub.inference._providers.hf_inference","huggingface_hub.inference._providers.hyperbolic","huggingface_hub.inference._providers.nebius","huggingface_hub.inference._providers.novita","huggingface_hub.inference._providers.nscale","huggingface_hub.inference._providers.openai","huggingface_hub.inference._providers.publicai","huggingface_hub.inference._providers.replicate","huggingface_hub.inference._providers.sambanova","huggingface_hub.inference._providers.scaleway","huggingface_hub.inference._providers.together","huggingface_hub.inference._providers.wavespeed","huggingface_hub.inference._providers.zai_org","huggingface_hub.utils.logging","huggingface_hub.utils","typing","builtins","_frozen_importlib","abc","logging"],"hash":"57882ae34b1a8ec09a15d604f72cd318d208f3bc","id":"huggingface_hub.inference._providers","ignore_all":true,"interface_hash":"fe245516669112b592838d6a91763e0ea042c362","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/__init__.py","plugin_data":null,"size":9974,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/_common.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/_common.data.json new file mode 100644 index 0000000000000000000000000000000000000000..af078a809597d3a330c20d2719aa4ea5d3bdbeb1 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/_common.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._providers._common","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"AutoRouterConversationalTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.BaseConversationalTask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers._common.AutoRouterConversationalTask","name":"AutoRouterConversationalTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers._common.AutoRouterConversationalTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers._common","mro":["huggingface_hub.inference._providers._common.AutoRouterConversationalTask","huggingface_hub.inference._providers._common.BaseConversationalTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers._common.AutoRouterConversationalTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"_prepare_base_url":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers._common.AutoRouterConversationalTask._prepare_base_url","name":"_prepare_base_url","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","api_key"],"arg_types":["huggingface_hub.inference._providers._common.AutoRouterConversationalTask","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_base_url of AutoRouterConversationalTask","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_mapping_info":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","model"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers._common.AutoRouterConversationalTask._prepare_mapping_info","name":"_prepare_mapping_info","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","model"],"arg_types":["huggingface_hub.inference._providers._common.AutoRouterConversationalTask",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_mapping_info of AutoRouterConversationalTask","ret_type":"huggingface_hub.hf_api.InferenceProviderMapping","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers._common.AutoRouterConversationalTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers._common.AutoRouterConversationalTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"BaseConversationalTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.TaskProviderHelper"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers._common.BaseConversationalTask","name":"BaseConversationalTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers._common.BaseConversationalTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers._common","mro":["huggingface_hub.inference._providers._common.BaseConversationalTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","provider","base_url"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers._common.BaseConversationalTask.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","provider","base_url"],"arg_types":["huggingface_hub.inference._providers._common.BaseConversationalTask","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of BaseConversationalTask","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_payload_as_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers._common.BaseConversationalTask._prepare_payload_as_dict","name":"_prepare_payload_as_dict","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"arg_types":["huggingface_hub.inference._providers._common.BaseConversationalTask",{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_dict of BaseConversationalTask","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_route":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers._common.BaseConversationalTask._prepare_route","name":"_prepare_route","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"arg_types":["huggingface_hub.inference._providers._common.BaseConversationalTask","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_route of BaseConversationalTask","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers._common.BaseConversationalTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers._common.BaseConversationalTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"BaseTextGenerationTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.TaskProviderHelper"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers._common.BaseTextGenerationTask","name":"BaseTextGenerationTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers._common.BaseTextGenerationTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers._common","mro":["huggingface_hub.inference._providers._common.BaseTextGenerationTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","provider","base_url"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers._common.BaseTextGenerationTask.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","provider","base_url"],"arg_types":["huggingface_hub.inference._providers._common.BaseTextGenerationTask","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of BaseTextGenerationTask","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_payload_as_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers._common.BaseTextGenerationTask._prepare_payload_as_dict","name":"_prepare_payload_as_dict","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"arg_types":["huggingface_hub.inference._providers._common.BaseTextGenerationTask",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_dict of BaseTextGenerationTask","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_route":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers._common.BaseTextGenerationTask._prepare_route","name":"_prepare_route","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"arg_types":["huggingface_hub.inference._providers._common.BaseTextGenerationTask","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_route of BaseTextGenerationTask","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers._common.BaseTextGenerationTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers._common.BaseTextGenerationTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ChatCompletionInputMessage":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputMessage","kind":"Gdef"},"HARDCODED_MODEL_INFERENCE_MAPPING":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"huggingface_hub.inference._providers._common.HARDCODED_MODEL_INFERENCE_MAPPING","name":"HARDCODED_MODEL_INFERENCE_MAPPING","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str","huggingface_hub.hf_api.InferenceProviderMapping"],"extra_attrs":null,"type_ref":"builtins.dict"}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"InferenceProviderMapping":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.hf_api.InferenceProviderMapping","kind":"Gdef"},"MimeBytes":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common.MimeBytes","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"RequestParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common.RequestParameters","kind":"Gdef"},"TaskProviderHelper":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers._common.TaskProviderHelper","name":"TaskProviderHelper","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers._common.TaskProviderHelper","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers._common","mro":["huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","provider","base_url","task"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers._common.TaskProviderHelper.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","provider","base_url","task"],"arg_types":["huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.str","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of TaskProviderHelper","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_normalize_headers":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","headers","payload","data"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers._common.TaskProviderHelper._normalize_headers","name":"_normalize_headers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","headers","payload","data"],"arg_types":["huggingface_hub.inference._providers._common.TaskProviderHelper",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._common.MimeBytes",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_normalize_headers of TaskProviderHelper","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_api_key":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers._common.TaskProviderHelper._prepare_api_key","name":"_prepare_api_key","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","api_key"],"arg_types":["huggingface_hub.inference._providers._common.TaskProviderHelper",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_api_key of TaskProviderHelper","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_base_url":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers._common.TaskProviderHelper._prepare_base_url","name":"_prepare_base_url","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","api_key"],"arg_types":["huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_base_url of TaskProviderHelper","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_headers":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","headers","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers._common.TaskProviderHelper._prepare_headers","name":"_prepare_headers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","headers","api_key"],"arg_types":["huggingface_hub.inference._providers._common.TaskProviderHelper",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_headers of TaskProviderHelper","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_mapping_info":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","model"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers._common.TaskProviderHelper._prepare_mapping_info","name":"_prepare_mapping_info","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","model"],"arg_types":["huggingface_hub.inference._providers._common.TaskProviderHelper",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_mapping_info of TaskProviderHelper","ret_type":"huggingface_hub.hf_api.InferenceProviderMapping","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_payload_as_bytes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info","extra_payload"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers._common.TaskProviderHelper._prepare_payload_as_bytes","name":"_prepare_payload_as_bytes","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info","extra_payload"],"arg_types":["huggingface_hub.inference._providers._common.TaskProviderHelper",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping",{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_bytes of TaskProviderHelper","ret_type":{".class":"UnionType","items":["huggingface_hub.inference._common.MimeBytes",{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_payload_as_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers._common.TaskProviderHelper._prepare_payload_as_dict","name":"_prepare_payload_as_dict","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"arg_types":["huggingface_hub.inference._providers._common.TaskProviderHelper",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_dict of TaskProviderHelper","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_route":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers._common.TaskProviderHelper._prepare_route","name":"_prepare_route","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"arg_types":["huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_route of TaskProviderHelper","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_url":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","api_key","mapped_model"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers._common.TaskProviderHelper._prepare_url","name":"_prepare_url","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","api_key","mapped_model"],"arg_types":["huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_url of TaskProviderHelper","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"base_url":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._providers._common.TaskProviderHelper.base_url","name":"base_url","setter_type":null,"type":"builtins.str"}},"get_response":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers._common.TaskProviderHelper.get_response","name":"get_response","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"arg_types":["huggingface_hub.inference._providers._common.TaskProviderHelper",{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._common.RequestParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_response of TaskProviderHelper","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"prepare_request":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,3,3,3,3,5],"arg_names":["self","inputs","parameters","headers","model","api_key","extra_payload"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers._common.TaskProviderHelper.prepare_request","name":"prepare_request","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3,3,3,3,3,5],"arg_names":["self","inputs","parameters","headers","model","api_key","extra_payload"],"arg_types":["huggingface_hub.inference._providers._common.TaskProviderHelper",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prepare_request of TaskProviderHelper","ret_type":"huggingface_hub.inference._common.RequestParameters","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"provider":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._providers._common.TaskProviderHelper.provider","name":"provider","setter_type":null,"type":"builtins.str"}},"task":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._providers._common.TaskProviderHelper.task","name":"task","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers._common.TaskProviderHelper.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers._common.TaskProviderHelper","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers._common.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers._common.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers._common.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers._common.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers._common.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers._common.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_fetch_inference_provider_mapping":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["model"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated"],"fullname":"huggingface_hub.inference._providers._common._fetch_inference_provider_mapping","name":"_fetch_inference_provider_mapping","original_first_arg":"model","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["model"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_fetch_inference_provider_mapping","ret_type":{".class":"Instance","args":["huggingface_hub.hf_api.InferenceProviderMapping"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._providers._common._fetch_inference_provider_mapping","name":"_fetch_inference_provider_mapping","setter_type":null,"type":{".class":"Instance","args":[{".class":"Instance","args":["huggingface_hub.hf_api.InferenceProviderMapping"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"functools._lru_cache_wrapper"}}}},"build_hf_headers":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._headers.build_hf_headers","kind":"Gdef"},"constants":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.constants","kind":"Gdef"},"filter_none":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers._common.filter_none","impl":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload"],"fullname":"huggingface_hub.inference._providers._common.filter_none","name":"filter_none","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"filter_none","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"huggingface_hub.inference._providers._common.filter_none","name":"filter_none","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"filter_none","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._providers._common.filter_none","name":"filter_none","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"filter_none","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"huggingface_hub.inference._providers._common.filter_none","name":"filter_none","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"filter_none","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._providers._common.filter_none","name":"filter_none","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"filter_none","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"filter_none","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"filter_none","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"get_token":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._auth.get_token","kind":"Gdef"},"logger":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.inference._providers._common.logger","name":"logger","setter_type":null,"type":"logging.Logger"}},"logging":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils.logging","kind":"Gdef"},"lru_cache":{".class":"SymbolTableNode","cross_ref":"functools.lru_cache","kind":"Gdef"},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef"},"recursive_merge":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["dict1","dict2"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers._common.recursive_merge","name":"recursive_merge","original_first_arg":"dict1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["dict1","dict2"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"recursive_merge","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/_common.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/_common.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/_common.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..03b8b9892935ae570e91a652c63324b8b2e2a47d --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/_common.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[7,6,8,4,5,8,1,2,4,1,1,1,1,1,1,1],"dep_prios":[5,5,10,10,5,5,5,5,20,5,30,30,30,30,30,30],"dependencies":["huggingface_hub.inference._generated.types.chat_completion","huggingface_hub.inference._common","huggingface_hub.utils.logging","huggingface_hub.constants","huggingface_hub.hf_api","huggingface_hub.utils","functools","typing","huggingface_hub","builtins","_frozen_importlib","abc","huggingface_hub.inference._generated","huggingface_hub.inference._generated.types","huggingface_hub.inference._generated.types.base","logging"],"hash":"ca405e1606ced067492ea1ea04a2de5ff31cc33e","id":"huggingface_hub.inference._providers._common","ignore_all":true,"interface_hash":"34dca2fb6e231e2f6c0558fa8a427c580114ef84","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/_common.py","plugin_data":null,"size":13839,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/black_forest_labs.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/black_forest_labs.data.json new file mode 100644 index 0000000000000000000000000000000000000000..7c3e9a7b38f4cf73f4be535ad10b3f9cdb6d33b3 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/black_forest_labs.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._providers.black_forest_labs","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BlackForestLabsTextToImageTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.TaskProviderHelper"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.black_forest_labs.BlackForestLabsTextToImageTask","name":"BlackForestLabsTextToImageTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.black_forest_labs.BlackForestLabsTextToImageTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers.black_forest_labs","mro":["huggingface_hub.inference._providers.black_forest_labs.BlackForestLabsTextToImageTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.black_forest_labs.BlackForestLabsTextToImageTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"_prepare_headers":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","headers","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.black_forest_labs.BlackForestLabsTextToImageTask._prepare_headers","name":"_prepare_headers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","headers","api_key"],"arg_types":["huggingface_hub.inference._providers.black_forest_labs.BlackForestLabsTextToImageTask",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_headers of BlackForestLabsTextToImageTask","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_payload_as_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.black_forest_labs.BlackForestLabsTextToImageTask._prepare_payload_as_dict","name":"_prepare_payload_as_dict","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"arg_types":["huggingface_hub.inference._providers.black_forest_labs.BlackForestLabsTextToImageTask",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_dict of BlackForestLabsTextToImageTask","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_route":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.black_forest_labs.BlackForestLabsTextToImageTask._prepare_route","name":"_prepare_route","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"arg_types":["huggingface_hub.inference._providers.black_forest_labs.BlackForestLabsTextToImageTask","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_route of BlackForestLabsTextToImageTask","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_response":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.black_forest_labs.BlackForestLabsTextToImageTask.get_response","name":"get_response","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"arg_types":["huggingface_hub.inference._providers.black_forest_labs.BlackForestLabsTextToImageTask",{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._common.RequestParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_response of BlackForestLabsTextToImageTask","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.black_forest_labs.BlackForestLabsTextToImageTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.black_forest_labs.BlackForestLabsTextToImageTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"InferenceProviderMapping":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.hf_api.InferenceProviderMapping","kind":"Gdef"},"MAX_POLLING_ATTEMPTS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.inference._providers.black_forest_labs.MAX_POLLING_ATTEMPTS","name":"MAX_POLLING_ATTEMPTS","setter_type":null,"type":"builtins.int"}},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"POLLING_INTERVAL":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.inference._providers.black_forest_labs.POLLING_INTERVAL","name":"POLLING_INTERVAL","setter_type":null,"type":"builtins.float"}},"RequestParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common.RequestParameters","kind":"Gdef"},"TaskProviderHelper":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.TaskProviderHelper","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.black_forest_labs.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.black_forest_labs.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.black_forest_labs.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.black_forest_labs.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.black_forest_labs.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.black_forest_labs.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_as_dict":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._as_dict","kind":"Gdef"},"filter_none":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.filter_none","kind":"Gdef"},"get_session":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._http.get_session","kind":"Gdef"},"logger":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.inference._providers.black_forest_labs.logger","name":"logger","setter_type":null,"type":"logging.Logger"}},"logging":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils.logging","kind":"Gdef"},"time":{".class":"SymbolTableNode","cross_ref":"time","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/black_forest_labs.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/black_forest_labs.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/black_forest_labs.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..f3cde3da2d3810256a6a709a0c7421f019a042e0 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/black_forest_labs.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[6,5,7,8,4,7,1,2,1,1,1,1],"dep_prios":[5,5,10,5,5,20,10,5,5,30,30,30],"dependencies":["huggingface_hub.inference._providers._common","huggingface_hub.inference._common","huggingface_hub.utils.logging","huggingface_hub.utils._http","huggingface_hub.hf_api","huggingface_hub.utils","time","typing","builtins","_frozen_importlib","abc","logging"],"hash":"4f9035eb2014bfb632f5e701abd2c9d1be23d69d","id":"huggingface_hub.inference._providers.black_forest_labs","ignore_all":true,"interface_hash":"7cbec3ebdbdc4138afb8b8f402180e33d462d854","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/black_forest_labs.py","plugin_data":null,"size":2846,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/cerebras.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/cerebras.data.json new file mode 100644 index 0000000000000000000000000000000000000000..13262f8348d05929e1fe996a26f09cc10d7fd841 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/cerebras.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._providers.cerebras","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","BaseConversationalTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.BaseConversationalTask","kind":"Gdef"},"CerebrasConversationalTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.BaseConversationalTask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.cerebras.CerebrasConversationalTask","name":"CerebrasConversationalTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.cerebras.CerebrasConversationalTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers.cerebras","mro":["huggingface_hub.inference._providers.cerebras.CerebrasConversationalTask","huggingface_hub.inference._providers._common.BaseConversationalTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.cerebras.CerebrasConversationalTask.__init__","name":"__init__","original_first_arg":"self","type":null}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.cerebras.CerebrasConversationalTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.cerebras.CerebrasConversationalTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.cerebras.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.cerebras.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.cerebras.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.cerebras.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.cerebras.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.cerebras.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/cerebras.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/cerebras.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/cerebras.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..cb3d600de0154fd2c30f3dccbe883bb093a88efd --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/cerebras.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[1,1,1,1,1],"dep_prios":[5,5,30,30,30],"dependencies":["huggingface_hub.inference._providers._common","builtins","_frozen_importlib","abc","typing"],"hash":"50b60e6c6e67c140f0a20d1e7fef5384732d4817","id":"huggingface_hub.inference._providers.cerebras","ignore_all":true,"interface_hash":"22c3f99bc6996dca8e9ed817004bb270c57441b5","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/cerebras.py","plugin_data":null,"size":210,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/clarifai.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/clarifai.data.json new file mode 100644 index 0000000000000000000000000000000000000000..4b9b54e1c4e06fa2b510db268a89c0e0250a82fe --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/clarifai.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._providers.clarifai","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","BaseConversationalTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.BaseConversationalTask","kind":"Gdef"},"ClarifaiConversationalTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.BaseConversationalTask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.clarifai.ClarifaiConversationalTask","name":"ClarifaiConversationalTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.clarifai.ClarifaiConversationalTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers.clarifai","mro":["huggingface_hub.inference._providers.clarifai.ClarifaiConversationalTask","huggingface_hub.inference._providers._common.BaseConversationalTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.clarifai.ClarifaiConversationalTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"_prepare_route":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.clarifai.ClarifaiConversationalTask._prepare_route","name":"_prepare_route","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"arg_types":["huggingface_hub.inference._providers.clarifai.ClarifaiConversationalTask","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_route of ClarifaiConversationalTask","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.clarifai.ClarifaiConversationalTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.clarifai.ClarifaiConversationalTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_BASE_URL":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.inference._providers.clarifai._BASE_URL","name":"_BASE_URL","setter_type":null,"type":"builtins.str"}},"_PROVIDER":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.inference._providers.clarifai._PROVIDER","name":"_PROVIDER","setter_type":null,"type":"builtins.str"}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.clarifai.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.clarifai.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.clarifai.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.clarifai.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.clarifai.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.clarifai.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/clarifai.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/clarifai.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/clarifai.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..92cd76e2e4fdd802724b17bee2935dde29a40ba0 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/clarifai.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[1,1,1,1,1],"dep_prios":[5,5,30,30,30],"dependencies":["huggingface_hub.inference._providers._common","builtins","_frozen_importlib","abc","typing"],"hash":"685dc83b0884d81d5db1e79291499c7f97d9b2f6","id":"huggingface_hub.inference._providers.clarifai","ignore_all":true,"interface_hash":"7259fa80f2977898d3ad1c24fc5cbc9713a3e6db","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/clarifai.py","plugin_data":null,"size":380,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/cohere.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/cohere.data.json new file mode 100644 index 0000000000000000000000000000000000000000..9b8f916166dd6d1539311e4355adeb38fbcbb957 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/cohere.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._providers.cohere","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseConversationalTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.BaseConversationalTask","kind":"Gdef"},"CohereConversationalTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.BaseConversationalTask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.cohere.CohereConversationalTask","name":"CohereConversationalTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.cohere.CohereConversationalTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers.cohere","mro":["huggingface_hub.inference._providers.cohere.CohereConversationalTask","huggingface_hub.inference._providers._common.BaseConversationalTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.cohere.CohereConversationalTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"_prepare_payload_as_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.cohere.CohereConversationalTask._prepare_payload_as_dict","name":"_prepare_payload_as_dict","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"arg_types":["huggingface_hub.inference._providers.cohere.CohereConversationalTask",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_dict of CohereConversationalTask","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_route":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.cohere.CohereConversationalTask._prepare_route","name":"_prepare_route","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"arg_types":["huggingface_hub.inference._providers.cohere.CohereConversationalTask","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_route of CohereConversationalTask","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.cohere.CohereConversationalTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.cohere.CohereConversationalTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"InferenceProviderMapping":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.hf_api.InferenceProviderMapping","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"_BASE_URL":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.inference._providers.cohere._BASE_URL","name":"_BASE_URL","setter_type":null,"type":"builtins.str"}},"_PROVIDER":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.inference._providers.cohere._PROVIDER","name":"_PROVIDER","setter_type":null,"type":"builtins.str"}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.cohere.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.cohere.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.cohere.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.cohere.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.cohere.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.cohere.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/cohere.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/cohere.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/cohere.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..41723f7742c7a554116dd1c3bc3e7caf516e6bbf --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/cohere.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[5,3,1,1,1,1],"dep_prios":[5,5,5,5,30,30],"dependencies":["huggingface_hub.inference._providers._common","huggingface_hub.hf_api","typing","builtins","_frozen_importlib","abc"],"hash":"f4834419e81c17ab98de44cbf12c81cd330f5e8c","id":"huggingface_hub.inference._providers.cohere","ignore_all":true,"interface_hash":"63b8051080fcf6f6525133de76e8ca3b29762eec","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/cohere.py","plugin_data":null,"size":1247,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/fal_ai.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/fal_ai.data.json new file mode 100644 index 0000000000000000000000000000000000000000..3bdd286ff3e202df61b28d97992d30432b13de80 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/fal_ai.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._providers.fal_ai","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","ABC":{".class":"SymbolTableNode","cross_ref":"abc.ABC","kind":"Gdef"},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"FalAIAutomaticSpeechRecognitionTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers.fal_ai.FalAITask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.fal_ai.FalAIAutomaticSpeechRecognitionTask","name":"FalAIAutomaticSpeechRecognitionTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAIAutomaticSpeechRecognitionTask","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._providers.fal_ai","mro":["huggingface_hub.inference._providers.fal_ai.FalAIAutomaticSpeechRecognitionTask","huggingface_hub.inference._providers.fal_ai.FalAITask","huggingface_hub.inference._providers._common.TaskProviderHelper","abc.ABC","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAIAutomaticSpeechRecognitionTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"_prepare_payload_as_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAIAutomaticSpeechRecognitionTask._prepare_payload_as_dict","name":"_prepare_payload_as_dict","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"arg_types":["huggingface_hub.inference._providers.fal_ai.FalAIAutomaticSpeechRecognitionTask",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_dict of FalAIAutomaticSpeechRecognitionTask","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_response":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAIAutomaticSpeechRecognitionTask.get_response","name":"get_response","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"arg_types":["huggingface_hub.inference._providers.fal_ai.FalAIAutomaticSpeechRecognitionTask",{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._common.RequestParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_response of FalAIAutomaticSpeechRecognitionTask","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.fal_ai.FalAIAutomaticSpeechRecognitionTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.fal_ai.FalAIAutomaticSpeechRecognitionTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"FalAIImageSegmentationTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers.fal_ai.FalAIQueueTask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.fal_ai.FalAIImageSegmentationTask","name":"FalAIImageSegmentationTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAIImageSegmentationTask","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._providers.fal_ai","mro":["huggingface_hub.inference._providers.fal_ai.FalAIImageSegmentationTask","huggingface_hub.inference._providers.fal_ai.FalAIQueueTask","huggingface_hub.inference._providers._common.TaskProviderHelper","abc.ABC","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAIImageSegmentationTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"_prepare_payload_as_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAIImageSegmentationTask._prepare_payload_as_dict","name":"_prepare_payload_as_dict","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"arg_types":["huggingface_hub.inference._providers.fal_ai.FalAIImageSegmentationTask",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_dict of FalAIImageSegmentationTask","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_response":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAIImageSegmentationTask.get_response","name":"get_response","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"arg_types":["huggingface_hub.inference._providers.fal_ai.FalAIImageSegmentationTask",{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._common.RequestParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_response of FalAIImageSegmentationTask","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.fal_ai.FalAIImageSegmentationTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.fal_ai.FalAIImageSegmentationTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"FalAIImageToImageTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers.fal_ai.FalAIQueueTask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.fal_ai.FalAIImageToImageTask","name":"FalAIImageToImageTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAIImageToImageTask","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._providers.fal_ai","mro":["huggingface_hub.inference._providers.fal_ai.FalAIImageToImageTask","huggingface_hub.inference._providers.fal_ai.FalAIQueueTask","huggingface_hub.inference._providers._common.TaskProviderHelper","abc.ABC","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAIImageToImageTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"_prepare_payload_as_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAIImageToImageTask._prepare_payload_as_dict","name":"_prepare_payload_as_dict","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"arg_types":["huggingface_hub.inference._providers.fal_ai.FalAIImageToImageTask",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_dict of FalAIImageToImageTask","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_response":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAIImageToImageTask.get_response","name":"get_response","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"arg_types":["huggingface_hub.inference._providers.fal_ai.FalAIImageToImageTask",{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._common.RequestParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_response of FalAIImageToImageTask","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.fal_ai.FalAIImageToImageTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.fal_ai.FalAIImageToImageTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"FalAIImageToVideoTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers.fal_ai.FalAIQueueTask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.fal_ai.FalAIImageToVideoTask","name":"FalAIImageToVideoTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAIImageToVideoTask","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._providers.fal_ai","mro":["huggingface_hub.inference._providers.fal_ai.FalAIImageToVideoTask","huggingface_hub.inference._providers.fal_ai.FalAIQueueTask","huggingface_hub.inference._providers._common.TaskProviderHelper","abc.ABC","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAIImageToVideoTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"_prepare_payload_as_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAIImageToVideoTask._prepare_payload_as_dict","name":"_prepare_payload_as_dict","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"arg_types":["huggingface_hub.inference._providers.fal_ai.FalAIImageToVideoTask",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_dict of FalAIImageToVideoTask","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_response":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAIImageToVideoTask.get_response","name":"get_response","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"arg_types":["huggingface_hub.inference._providers.fal_ai.FalAIImageToVideoTask",{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._common.RequestParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_response of FalAIImageToVideoTask","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.fal_ai.FalAIImageToVideoTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.fal_ai.FalAIImageToVideoTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"FalAIQueueTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.TaskProviderHelper","abc.ABC"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.fal_ai.FalAIQueueTask","name":"FalAIQueueTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAIQueueTask","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._providers.fal_ai","mro":["huggingface_hub.inference._providers.fal_ai.FalAIQueueTask","huggingface_hub.inference._providers._common.TaskProviderHelper","abc.ABC","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","task"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAIQueueTask.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","task"],"arg_types":["huggingface_hub.inference._providers.fal_ai.FalAIQueueTask","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of FalAIQueueTask","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_headers":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","headers","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAIQueueTask._prepare_headers","name":"_prepare_headers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","headers","api_key"],"arg_types":["huggingface_hub.inference._providers.fal_ai.FalAIQueueTask",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_headers of FalAIQueueTask","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_route":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAIQueueTask._prepare_route","name":"_prepare_route","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"arg_types":["huggingface_hub.inference._providers.fal_ai.FalAIQueueTask","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_route of FalAIQueueTask","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_response":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAIQueueTask.get_response","name":"get_response","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"arg_types":["huggingface_hub.inference._providers.fal_ai.FalAIQueueTask",{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._common.RequestParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_response of FalAIQueueTask","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.fal_ai.FalAIQueueTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.fal_ai.FalAIQueueTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"FalAITask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.TaskProviderHelper","abc.ABC"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.fal_ai.FalAITask","name":"FalAITask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAITask","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._providers.fal_ai","mro":["huggingface_hub.inference._providers.fal_ai.FalAITask","huggingface_hub.inference._providers._common.TaskProviderHelper","abc.ABC","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","task"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAITask.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","task"],"arg_types":["huggingface_hub.inference._providers.fal_ai.FalAITask","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of FalAITask","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_headers":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","headers","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAITask._prepare_headers","name":"_prepare_headers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","headers","api_key"],"arg_types":["huggingface_hub.inference._providers.fal_ai.FalAITask",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_headers of FalAITask","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_route":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAITask._prepare_route","name":"_prepare_route","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"arg_types":["huggingface_hub.inference._providers.fal_ai.FalAITask","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_route of FalAITask","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.fal_ai.FalAITask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.fal_ai.FalAITask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"FalAITextToImageTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers.fal_ai.FalAITask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.fal_ai.FalAITextToImageTask","name":"FalAITextToImageTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAITextToImageTask","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._providers.fal_ai","mro":["huggingface_hub.inference._providers.fal_ai.FalAITextToImageTask","huggingface_hub.inference._providers.fal_ai.FalAITask","huggingface_hub.inference._providers._common.TaskProviderHelper","abc.ABC","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAITextToImageTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"_prepare_payload_as_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAITextToImageTask._prepare_payload_as_dict","name":"_prepare_payload_as_dict","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"arg_types":["huggingface_hub.inference._providers.fal_ai.FalAITextToImageTask",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_dict of FalAITextToImageTask","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_response":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAITextToImageTask.get_response","name":"get_response","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"arg_types":["huggingface_hub.inference._providers.fal_ai.FalAITextToImageTask",{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._common.RequestParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_response of FalAITextToImageTask","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.fal_ai.FalAITextToImageTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.fal_ai.FalAITextToImageTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"FalAITextToSpeechTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers.fal_ai.FalAITask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.fal_ai.FalAITextToSpeechTask","name":"FalAITextToSpeechTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAITextToSpeechTask","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._providers.fal_ai","mro":["huggingface_hub.inference._providers.fal_ai.FalAITextToSpeechTask","huggingface_hub.inference._providers.fal_ai.FalAITask","huggingface_hub.inference._providers._common.TaskProviderHelper","abc.ABC","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAITextToSpeechTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"_prepare_payload_as_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAITextToSpeechTask._prepare_payload_as_dict","name":"_prepare_payload_as_dict","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"arg_types":["huggingface_hub.inference._providers.fal_ai.FalAITextToSpeechTask",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_dict of FalAITextToSpeechTask","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_response":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAITextToSpeechTask.get_response","name":"get_response","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"arg_types":["huggingface_hub.inference._providers.fal_ai.FalAITextToSpeechTask",{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._common.RequestParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_response of FalAITextToSpeechTask","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.fal_ai.FalAITextToSpeechTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.fal_ai.FalAITextToSpeechTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"FalAITextToVideoTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers.fal_ai.FalAIQueueTask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.fal_ai.FalAITextToVideoTask","name":"FalAITextToVideoTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAITextToVideoTask","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._providers.fal_ai","mro":["huggingface_hub.inference._providers.fal_ai.FalAITextToVideoTask","huggingface_hub.inference._providers.fal_ai.FalAIQueueTask","huggingface_hub.inference._providers._common.TaskProviderHelper","abc.ABC","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAITextToVideoTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"_prepare_payload_as_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAITextToVideoTask._prepare_payload_as_dict","name":"_prepare_payload_as_dict","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"arg_types":["huggingface_hub.inference._providers.fal_ai.FalAITextToVideoTask",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_dict of FalAITextToVideoTask","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_response":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.fal_ai.FalAITextToVideoTask.get_response","name":"get_response","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"arg_types":["huggingface_hub.inference._providers.fal_ai.FalAITextToVideoTask",{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._common.RequestParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_response of FalAITextToVideoTask","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.fal_ai.FalAITextToVideoTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.fal_ai.FalAITextToVideoTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"InferenceProviderMapping":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.hf_api.InferenceProviderMapping","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"RequestParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common.RequestParameters","kind":"Gdef"},"TaskProviderHelper":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.TaskProviderHelper","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"_POLLING_INTERVAL":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.inference._providers.fal_ai._POLLING_INTERVAL","name":"_POLLING_INTERVAL","setter_type":null,"type":"builtins.float"}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.fal_ai.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.fal_ai.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.fal_ai.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.fal_ai.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.fal_ai.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.fal_ai.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_as_dict":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._as_dict","kind":"Gdef"},"_as_url":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._as_url","kind":"Gdef"},"base64":{".class":"SymbolTableNode","cross_ref":"base64","kind":"Gdef"},"constants":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.constants","kind":"Gdef"},"filter_none":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.filter_none","kind":"Gdef"},"get_logger":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils.logging.get_logger","kind":"Gdef"},"get_session":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._http.get_session","kind":"Gdef"},"hf_raise_for_status":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._http.hf_raise_for_status","kind":"Gdef"},"logger":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.inference._providers.fal_ai.logger","name":"logger","setter_type":null,"type":"logging.Logger"}},"time":{".class":"SymbolTableNode","cross_ref":"time","kind":"Gdef"},"urlparse":{".class":"SymbolTableNode","cross_ref":"urllib.parse.urlparse","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/fal_ai.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/fal_ai.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/fal_ai.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..ea7a81ce982209883cec9c5ee6e440c8c33a83ea --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/fal_ai.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[10,9,12,5,7,8,11,1,2,3,4,7,1,1,1],"dep_prios":[5,5,5,5,10,5,5,10,10,5,5,20,5,30,30],"dependencies":["huggingface_hub.inference._providers._common","huggingface_hub.inference._common","huggingface_hub.utils.logging","urllib.parse","huggingface_hub.constants","huggingface_hub.hf_api","huggingface_hub.utils","base64","time","abc","typing","huggingface_hub","builtins","_frozen_importlib","logging"],"hash":"c052e815dcfbfb01b7afc6c606eb1a645e56d448","id":"huggingface_hub.inference._providers.fal_ai","ignore_all":true,"interface_hash":"3383a8e80492c559fa4afe35178e664ab1dfba6c","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/fal_ai.py","plugin_data":null,"size":11766,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/featherless_ai.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/featherless_ai.data.json new file mode 100644 index 0000000000000000000000000000000000000000..aa36eb4226c5a5b833eae32d4436cb8045ee5a17 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/featherless_ai.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._providers.featherless_ai","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseConversationalTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.BaseConversationalTask","kind":"Gdef"},"BaseTextGenerationTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.BaseTextGenerationTask","kind":"Gdef"},"FeatherlessConversationalTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.BaseConversationalTask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.featherless_ai.FeatherlessConversationalTask","name":"FeatherlessConversationalTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.featherless_ai.FeatherlessConversationalTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers.featherless_ai","mro":["huggingface_hub.inference._providers.featherless_ai.FeatherlessConversationalTask","huggingface_hub.inference._providers._common.BaseConversationalTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.featherless_ai.FeatherlessConversationalTask.__init__","name":"__init__","original_first_arg":"self","type":null}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.featherless_ai.FeatherlessConversationalTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.featherless_ai.FeatherlessConversationalTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"FeatherlessTextGenerationTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.BaseTextGenerationTask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.featherless_ai.FeatherlessTextGenerationTask","name":"FeatherlessTextGenerationTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.featherless_ai.FeatherlessTextGenerationTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers.featherless_ai","mro":["huggingface_hub.inference._providers.featherless_ai.FeatherlessTextGenerationTask","huggingface_hub.inference._providers._common.BaseTextGenerationTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.featherless_ai.FeatherlessTextGenerationTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"_prepare_payload_as_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.featherless_ai.FeatherlessTextGenerationTask._prepare_payload_as_dict","name":"_prepare_payload_as_dict","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"arg_types":["huggingface_hub.inference._providers.featherless_ai.FeatherlessTextGenerationTask",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_dict of FeatherlessTextGenerationTask","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_response":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.featherless_ai.FeatherlessTextGenerationTask.get_response","name":"get_response","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"arg_types":["huggingface_hub.inference._providers.featherless_ai.FeatherlessTextGenerationTask",{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._common.RequestParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_response of FeatherlessTextGenerationTask","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.featherless_ai.FeatherlessTextGenerationTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.featherless_ai.FeatherlessTextGenerationTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"InferenceProviderMapping":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.hf_api.InferenceProviderMapping","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"RequestParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common.RequestParameters","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"_BASE_URL":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.inference._providers.featherless_ai._BASE_URL","name":"_BASE_URL","setter_type":null,"type":"builtins.str"}},"_PROVIDER":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.inference._providers.featherless_ai._PROVIDER","name":"_PROVIDER","setter_type":null,"type":"builtins.str"}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.featherless_ai.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.featherless_ai.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.featherless_ai.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.featherless_ai.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.featherless_ai.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.featherless_ai.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_as_dict":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._as_dict","kind":"Gdef"},"filter_none":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.filter_none","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/featherless_ai.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/featherless_ai.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/featherless_ai.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..54519958a050b07413bad2d1f11418bc9515becd --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/featherless_ai.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[6,4,3,1,1,1,1],"dep_prios":[5,5,5,5,5,30,30],"dependencies":["huggingface_hub.inference._providers._common","huggingface_hub.inference._common","huggingface_hub.hf_api","typing","builtins","_frozen_importlib","abc"],"hash":"7c9f3dd7dad17ca0b53f55047d2d662f9cc35d2b","id":"huggingface_hub.inference._providers.featherless_ai","ignore_all":true,"interface_hash":"ecdf17d167ad5496bbe026209d2db977651620a5","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/featherless_ai.py","plugin_data":null,"size":1376,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/fireworks_ai.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/fireworks_ai.data.json new file mode 100644 index 0000000000000000000000000000000000000000..afaab0e750797e5139e5f14d23664bbffd006aa5 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/fireworks_ai.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._providers.fireworks_ai","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseConversationalTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.BaseConversationalTask","kind":"Gdef"},"FireworksAIConversationalTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.BaseConversationalTask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.fireworks_ai.FireworksAIConversationalTask","name":"FireworksAIConversationalTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.fireworks_ai.FireworksAIConversationalTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers.fireworks_ai","mro":["huggingface_hub.inference._providers.fireworks_ai.FireworksAIConversationalTask","huggingface_hub.inference._providers._common.BaseConversationalTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.fireworks_ai.FireworksAIConversationalTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"_prepare_payload_as_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.fireworks_ai.FireworksAIConversationalTask._prepare_payload_as_dict","name":"_prepare_payload_as_dict","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"arg_types":["huggingface_hub.inference._providers.fireworks_ai.FireworksAIConversationalTask",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_dict of FireworksAIConversationalTask","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_route":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.fireworks_ai.FireworksAIConversationalTask._prepare_route","name":"_prepare_route","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"arg_types":["huggingface_hub.inference._providers.fireworks_ai.FireworksAIConversationalTask","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_route of FireworksAIConversationalTask","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.fireworks_ai.FireworksAIConversationalTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.fireworks_ai.FireworksAIConversationalTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"InferenceProviderMapping":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.hf_api.InferenceProviderMapping","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.fireworks_ai.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.fireworks_ai.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.fireworks_ai.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.fireworks_ai.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.fireworks_ai.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.fireworks_ai.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/fireworks_ai.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/fireworks_ai.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/fireworks_ai.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..36e092049b8a2ee797868a90917b76b26fb7b52b --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/fireworks_ai.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[5,3,1,1,1,1],"dep_prios":[5,5,5,5,30,30],"dependencies":["huggingface_hub.inference._providers._common","huggingface_hub.hf_api","typing","builtins","_frozen_importlib","abc"],"hash":"ae650b922ea40eb34a89892b0da790c9e5835e25","id":"huggingface_hub.inference._providers.fireworks_ai","ignore_all":true,"interface_hash":"7a40f70bb0700e1af1f74d094d56b460c2e062e3","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/fireworks_ai.py","plugin_data":null,"size":1209,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/groq.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/groq.data.json new file mode 100644 index 0000000000000000000000000000000000000000..0573cadfc93c2999d6fc5a575a74d75f09e5be44 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/groq.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._providers.groq","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","BaseConversationalTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.BaseConversationalTask","kind":"Gdef"},"GroqConversationalTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.BaseConversationalTask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.groq.GroqConversationalTask","name":"GroqConversationalTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.groq.GroqConversationalTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers.groq","mro":["huggingface_hub.inference._providers.groq.GroqConversationalTask","huggingface_hub.inference._providers._common.BaseConversationalTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.groq.GroqConversationalTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"_prepare_route":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.groq.GroqConversationalTask._prepare_route","name":"_prepare_route","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"arg_types":["huggingface_hub.inference._providers.groq.GroqConversationalTask","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_route of GroqConversationalTask","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.groq.GroqConversationalTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.groq.GroqConversationalTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.groq.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.groq.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.groq.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.groq.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.groq.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.groq.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/groq.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/groq.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/groq.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..0642db9e7b6dfd2037321020b4a49229ab87a137 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/groq.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[1,1,1,1,1],"dep_prios":[5,5,30,30,30],"dependencies":["huggingface_hub.inference._providers._common","builtins","_frozen_importlib","abc","typing"],"hash":"7a09fd3fa9cc0ef68320952575b08217d78e6191","id":"huggingface_hub.inference._providers.groq","ignore_all":true,"interface_hash":"7d9dc169db359cc102364f2566326fb363a32dc3","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/groq.py","plugin_data":null,"size":315,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/hf_inference.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/hf_inference.data.json new file mode 100644 index 0000000000000000000000000000000000000000..1d5d4676ce5a3930ff972b97f1486ea9051ef04f --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/hf_inference.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._providers.hf_inference","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"HFInferenceBinaryInputTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers.hf_inference.HFInferenceTask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.hf_inference.HFInferenceBinaryInputTask","name":"HFInferenceBinaryInputTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.hf_inference.HFInferenceBinaryInputTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers.hf_inference","mro":["huggingface_hub.inference._providers.hf_inference.HFInferenceBinaryInputTask","huggingface_hub.inference._providers.hf_inference.HFInferenceTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","_prepare_payload_as_bytes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info","extra_payload"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.hf_inference.HFInferenceBinaryInputTask._prepare_payload_as_bytes","name":"_prepare_payload_as_bytes","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info","extra_payload"],"arg_types":["huggingface_hub.inference._providers.hf_inference.HFInferenceBinaryInputTask",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping",{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_bytes of HFInferenceBinaryInputTask","ret_type":{".class":"UnionType","items":["huggingface_hub.inference._common.MimeBytes",{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_payload_as_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.hf_inference.HFInferenceBinaryInputTask._prepare_payload_as_dict","name":"_prepare_payload_as_dict","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"arg_types":["huggingface_hub.inference._providers.hf_inference.HFInferenceBinaryInputTask",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_dict of HFInferenceBinaryInputTask","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.hf_inference.HFInferenceBinaryInputTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.hf_inference.HFInferenceBinaryInputTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"HFInferenceConversational":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers.hf_inference.HFInferenceTask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.hf_inference.HFInferenceConversational","name":"HFInferenceConversational","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.hf_inference.HFInferenceConversational","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers.hf_inference","mro":["huggingface_hub.inference._providers.hf_inference.HFInferenceConversational","huggingface_hub.inference._providers.hf_inference.HFInferenceTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.hf_inference.HFInferenceConversational.__init__","name":"__init__","original_first_arg":"self","type":null}},"_prepare_payload_as_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.hf_inference.HFInferenceConversational._prepare_payload_as_dict","name":"_prepare_payload_as_dict","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"arg_types":["huggingface_hub.inference._providers.hf_inference.HFInferenceConversational",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_dict of HFInferenceConversational","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_url":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","api_key","mapped_model"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.hf_inference.HFInferenceConversational._prepare_url","name":"_prepare_url","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","api_key","mapped_model"],"arg_types":["huggingface_hub.inference._providers.hf_inference.HFInferenceConversational","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_url of HFInferenceConversational","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.hf_inference.HFInferenceConversational.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.hf_inference.HFInferenceConversational","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"HFInferenceFeatureExtractionTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers.hf_inference.HFInferenceTask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.hf_inference.HFInferenceFeatureExtractionTask","name":"HFInferenceFeatureExtractionTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.hf_inference.HFInferenceFeatureExtractionTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers.hf_inference","mro":["huggingface_hub.inference._providers.hf_inference.HFInferenceFeatureExtractionTask","huggingface_hub.inference._providers.hf_inference.HFInferenceTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.hf_inference.HFInferenceFeatureExtractionTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"_prepare_payload_as_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.hf_inference.HFInferenceFeatureExtractionTask._prepare_payload_as_dict","name":"_prepare_payload_as_dict","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"arg_types":["huggingface_hub.inference._providers.hf_inference.HFInferenceFeatureExtractionTask",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_dict of HFInferenceFeatureExtractionTask","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_response":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.hf_inference.HFInferenceFeatureExtractionTask.get_response","name":"get_response","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"arg_types":["huggingface_hub.inference._providers.hf_inference.HFInferenceFeatureExtractionTask",{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._common.RequestParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_response of HFInferenceFeatureExtractionTask","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.hf_inference.HFInferenceFeatureExtractionTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.hf_inference.HFInferenceFeatureExtractionTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"HFInferenceTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.TaskProviderHelper"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.hf_inference.HFInferenceTask","name":"HFInferenceTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.hf_inference.HFInferenceTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers.hf_inference","mro":["huggingface_hub.inference._providers.hf_inference.HFInferenceTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","task"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.hf_inference.HFInferenceTask.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","task"],"arg_types":["huggingface_hub.inference._providers.hf_inference.HFInferenceTask","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of HFInferenceTask","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_api_key":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.hf_inference.HFInferenceTask._prepare_api_key","name":"_prepare_api_key","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","api_key"],"arg_types":["huggingface_hub.inference._providers.hf_inference.HFInferenceTask",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_api_key of HFInferenceTask","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_mapping_info":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","model"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.hf_inference.HFInferenceTask._prepare_mapping_info","name":"_prepare_mapping_info","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","model"],"arg_types":["huggingface_hub.inference._providers.hf_inference.HFInferenceTask",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_mapping_info of HFInferenceTask","ret_type":"huggingface_hub.hf_api.InferenceProviderMapping","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_payload_as_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.hf_inference.HFInferenceTask._prepare_payload_as_dict","name":"_prepare_payload_as_dict","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"arg_types":["huggingface_hub.inference._providers.hf_inference.HFInferenceTask",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_dict of HFInferenceTask","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_url":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","api_key","mapped_model"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.hf_inference.HFInferenceTask._prepare_url","name":"_prepare_url","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","api_key","mapped_model"],"arg_types":["huggingface_hub.inference._providers.hf_inference.HFInferenceTask","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_url of HFInferenceTask","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.hf_inference.HFInferenceTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.hf_inference.HFInferenceTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"InferenceProviderMapping":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.hf_api.InferenceProviderMapping","kind":"Gdef"},"MimeBytes":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common.MimeBytes","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"Path":{".class":"SymbolTableNode","cross_ref":"pathlib.Path","kind":"Gdef"},"RequestParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common.RequestParameters","kind":"Gdef"},"TaskProviderHelper":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.TaskProviderHelper","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.hf_inference.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.hf_inference.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.hf_inference.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.hf_inference.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.hf_inference.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.hf_inference.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_b64_encode":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._b64_encode","kind":"Gdef"},"_build_chat_completion_url":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["model_url"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.hf_inference._build_chat_completion_url","name":"_build_chat_completion_url","original_first_arg":"model_url","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["model_url"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_build_chat_completion_url","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_bytes_to_dict":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._bytes_to_dict","kind":"Gdef"},"_check_supported_task":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["model","task"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated"],"fullname":"huggingface_hub.inference._providers.hf_inference._check_supported_task","name":"_check_supported_task","original_first_arg":"model","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["model","task"],"arg_types":["builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_check_supported_task","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._providers.hf_inference._check_supported_task","name":"_check_supported_task","setter_type":null,"type":{".class":"Instance","args":[{".class":"NoneType"}],"extra_attrs":null,"type_ref":"functools._lru_cache_wrapper"}}}},"_fetch_recommended_models":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated"],"fullname":"huggingface_hub.inference._providers.hf_inference._fetch_recommended_models","name":"_fetch_recommended_models","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_fetch_recommended_models","ret_type":{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.inference._providers.hf_inference._fetch_recommended_models","name":"_fetch_recommended_models","setter_type":null,"type":{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"}],"extra_attrs":null,"type_ref":"functools._lru_cache_wrapper"}}}},"_open_as_mime_bytes":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._open_as_mime_bytes","kind":"Gdef"},"build_hf_headers":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._headers.build_hf_headers","kind":"Gdef"},"constants":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.constants","kind":"Gdef"},"filter_none":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.filter_none","kind":"Gdef"},"get_session":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._http.get_session","kind":"Gdef"},"get_token":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._auth.get_token","kind":"Gdef"},"hf_raise_for_status":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._http.hf_raise_for_status","kind":"Gdef"},"json":{".class":"SymbolTableNode","cross_ref":"json","kind":"Gdef"},"lru_cache":{".class":"SymbolTableNode","cross_ref":"functools.lru_cache","kind":"Gdef"},"urlparse":{".class":"SymbolTableNode","cross_ref":"urllib.parse.urlparse","kind":"Gdef"},"urlunparse":{".class":"SymbolTableNode","cross_ref":"urllib.parse.urlunparse","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/hf_inference.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/hf_inference.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/hf_inference.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..21c226f41b77ce8af729610c45c9477bb7fc73fb --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/hf_inference.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[16,9,5,7,8,17,1,2,3,4,7,1,1,1],"dep_prios":[5,5,5,10,5,5,10,5,5,5,20,5,30,30],"dependencies":["huggingface_hub.inference._providers._common","huggingface_hub.inference._common","urllib.parse","huggingface_hub.constants","huggingface_hub.hf_api","huggingface_hub.utils","json","functools","pathlib","typing","huggingface_hub","builtins","_frozen_importlib","abc"],"hash":"7bb27b0eb3e482146fc758046f1ec4e1aa8eea1f","id":"huggingface_hub.inference._providers.hf_inference","ignore_all":true,"interface_hash":"50a65b91f0949e167bfc5d32e148e590042a900b","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/hf_inference.py","plugin_data":null,"size":9534,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/hyperbolic.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/hyperbolic.data.json new file mode 100644 index 0000000000000000000000000000000000000000..8b7ee456ced256756e8961ae6de090fb171be981 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/hyperbolic.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._providers.hyperbolic","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseConversationalTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.BaseConversationalTask","kind":"Gdef"},"HyperbolicTextGenerationTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.BaseConversationalTask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.hyperbolic.HyperbolicTextGenerationTask","name":"HyperbolicTextGenerationTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.hyperbolic.HyperbolicTextGenerationTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers.hyperbolic","mro":["huggingface_hub.inference._providers.hyperbolic.HyperbolicTextGenerationTask","huggingface_hub.inference._providers._common.BaseConversationalTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","task"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.hyperbolic.HyperbolicTextGenerationTask.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","task"],"arg_types":["huggingface_hub.inference._providers.hyperbolic.HyperbolicTextGenerationTask","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of HyperbolicTextGenerationTask","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.hyperbolic.HyperbolicTextGenerationTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.hyperbolic.HyperbolicTextGenerationTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"HyperbolicTextToImageTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.TaskProviderHelper"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.hyperbolic.HyperbolicTextToImageTask","name":"HyperbolicTextToImageTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.hyperbolic.HyperbolicTextToImageTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers.hyperbolic","mro":["huggingface_hub.inference._providers.hyperbolic.HyperbolicTextToImageTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.hyperbolic.HyperbolicTextToImageTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"_prepare_payload_as_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.hyperbolic.HyperbolicTextToImageTask._prepare_payload_as_dict","name":"_prepare_payload_as_dict","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"arg_types":["huggingface_hub.inference._providers.hyperbolic.HyperbolicTextToImageTask",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_dict of HyperbolicTextToImageTask","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_route":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.hyperbolic.HyperbolicTextToImageTask._prepare_route","name":"_prepare_route","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"arg_types":["huggingface_hub.inference._providers.hyperbolic.HyperbolicTextToImageTask","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_route of HyperbolicTextToImageTask","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_response":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.hyperbolic.HyperbolicTextToImageTask.get_response","name":"get_response","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"arg_types":["huggingface_hub.inference._providers.hyperbolic.HyperbolicTextToImageTask",{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._common.RequestParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_response of HyperbolicTextToImageTask","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.hyperbolic.HyperbolicTextToImageTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.hyperbolic.HyperbolicTextToImageTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"InferenceProviderMapping":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.hf_api.InferenceProviderMapping","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"RequestParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common.RequestParameters","kind":"Gdef"},"TaskProviderHelper":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.TaskProviderHelper","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.hyperbolic.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.hyperbolic.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.hyperbolic.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.hyperbolic.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.hyperbolic.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.hyperbolic.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_as_dict":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._as_dict","kind":"Gdef"},"base64":{".class":"SymbolTableNode","cross_ref":"base64","kind":"Gdef"},"filter_none":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.filter_none","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/hyperbolic.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/hyperbolic.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/hyperbolic.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..78d156606b4f5ada844b188bc630f874c966e4bf --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/hyperbolic.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[6,5,4,1,2,1,1,1],"dep_prios":[5,5,5,10,5,5,30,30],"dependencies":["huggingface_hub.inference._providers._common","huggingface_hub.inference._common","huggingface_hub.hf_api","base64","typing","builtins","_frozen_importlib","abc"],"hash":"2e437da4d9d6d95c50a24305e8eab538a067d4ee","id":"huggingface_hub.inference._providers.hyperbolic","ignore_all":true,"interface_hash":"a4a9b310ab140dc2112b5259ecb6e96b32d1760f","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/hyperbolic.py","plugin_data":null,"size":1979,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/nebius.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/nebius.data.json new file mode 100644 index 0000000000000000000000000000000000000000..ecdd5618210a3333aea94056a250098557cf0b78 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/nebius.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._providers.nebius","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseConversationalTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.BaseConversationalTask","kind":"Gdef"},"BaseTextGenerationTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.BaseTextGenerationTask","kind":"Gdef"},"InferenceProviderMapping":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.hf_api.InferenceProviderMapping","kind":"Gdef"},"NebiusConversationalTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.BaseConversationalTask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.nebius.NebiusConversationalTask","name":"NebiusConversationalTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.nebius.NebiusConversationalTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers.nebius","mro":["huggingface_hub.inference._providers.nebius.NebiusConversationalTask","huggingface_hub.inference._providers._common.BaseConversationalTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.nebius.NebiusConversationalTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"_prepare_payload_as_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.nebius.NebiusConversationalTask._prepare_payload_as_dict","name":"_prepare_payload_as_dict","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"arg_types":["huggingface_hub.inference._providers.nebius.NebiusConversationalTask",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_dict of NebiusConversationalTask","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.nebius.NebiusConversationalTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.nebius.NebiusConversationalTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"NebiusFeatureExtractionTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.TaskProviderHelper"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.nebius.NebiusFeatureExtractionTask","name":"NebiusFeatureExtractionTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.nebius.NebiusFeatureExtractionTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers.nebius","mro":["huggingface_hub.inference._providers.nebius.NebiusFeatureExtractionTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.nebius.NebiusFeatureExtractionTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"_prepare_payload_as_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.nebius.NebiusFeatureExtractionTask._prepare_payload_as_dict","name":"_prepare_payload_as_dict","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"arg_types":["huggingface_hub.inference._providers.nebius.NebiusFeatureExtractionTask",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_dict of NebiusFeatureExtractionTask","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_route":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.nebius.NebiusFeatureExtractionTask._prepare_route","name":"_prepare_route","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"arg_types":["huggingface_hub.inference._providers.nebius.NebiusFeatureExtractionTask","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_route of NebiusFeatureExtractionTask","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_response":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.nebius.NebiusFeatureExtractionTask.get_response","name":"get_response","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"arg_types":["huggingface_hub.inference._providers.nebius.NebiusFeatureExtractionTask",{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._common.RequestParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_response of NebiusFeatureExtractionTask","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.nebius.NebiusFeatureExtractionTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.nebius.NebiusFeatureExtractionTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"NebiusTextGenerationTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.BaseTextGenerationTask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.nebius.NebiusTextGenerationTask","name":"NebiusTextGenerationTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.nebius.NebiusTextGenerationTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers.nebius","mro":["huggingface_hub.inference._providers.nebius.NebiusTextGenerationTask","huggingface_hub.inference._providers._common.BaseTextGenerationTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.nebius.NebiusTextGenerationTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"get_response":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.nebius.NebiusTextGenerationTask.get_response","name":"get_response","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"arg_types":["huggingface_hub.inference._providers.nebius.NebiusTextGenerationTask",{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._common.RequestParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_response of NebiusTextGenerationTask","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.nebius.NebiusTextGenerationTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.nebius.NebiusTextGenerationTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"NebiusTextToImageTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.TaskProviderHelper"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.nebius.NebiusTextToImageTask","name":"NebiusTextToImageTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.nebius.NebiusTextToImageTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers.nebius","mro":["huggingface_hub.inference._providers.nebius.NebiusTextToImageTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.nebius.NebiusTextToImageTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"_prepare_payload_as_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.nebius.NebiusTextToImageTask._prepare_payload_as_dict","name":"_prepare_payload_as_dict","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"arg_types":["huggingface_hub.inference._providers.nebius.NebiusTextToImageTask",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_dict of NebiusTextToImageTask","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_route":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.nebius.NebiusTextToImageTask._prepare_route","name":"_prepare_route","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"arg_types":["huggingface_hub.inference._providers.nebius.NebiusTextToImageTask","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_route of NebiusTextToImageTask","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_response":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.nebius.NebiusTextToImageTask.get_response","name":"get_response","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"arg_types":["huggingface_hub.inference._providers.nebius.NebiusTextToImageTask",{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._common.RequestParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_response of NebiusTextToImageTask","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.nebius.NebiusTextToImageTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.nebius.NebiusTextToImageTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"RequestParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common.RequestParameters","kind":"Gdef"},"TaskProviderHelper":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.TaskProviderHelper","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.nebius.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.nebius.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.nebius.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.nebius.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.nebius.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.nebius.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_as_dict":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._as_dict","kind":"Gdef"},"base64":{".class":"SymbolTableNode","cross_ref":"base64","kind":"Gdef"},"filter_none":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.filter_none","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/nebius.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/nebius.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/nebius.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..3f3999083e042aeeaa437d6633bc5d9b4c09ac2a --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/nebius.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[6,5,4,1,2,1,1,1],"dep_prios":[5,5,5,10,5,5,30,30],"dependencies":["huggingface_hub.inference._providers._common","huggingface_hub.inference._common","huggingface_hub.hf_api","base64","typing","builtins","_frozen_importlib","abc"],"hash":"f64cfb866454a188621de84f6f679539c191cd64","id":"huggingface_hub.inference._providers.nebius","ignore_all":true,"interface_hash":"073f907c2084d28def72d1d1bdd0faa9c8ac1e86","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/nebius.py","plugin_data":null,"size":3574,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/novita.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/novita.data.json new file mode 100644 index 0000000000000000000000000000000000000000..1aeaf47fc1087e85864294955326957bacd1051d --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/novita.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._providers.novita","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseConversationalTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.BaseConversationalTask","kind":"Gdef"},"BaseTextGenerationTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.BaseTextGenerationTask","kind":"Gdef"},"InferenceProviderMapping":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.hf_api.InferenceProviderMapping","kind":"Gdef"},"NovitaConversationalTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.BaseConversationalTask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.novita.NovitaConversationalTask","name":"NovitaConversationalTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.novita.NovitaConversationalTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers.novita","mro":["huggingface_hub.inference._providers.novita.NovitaConversationalTask","huggingface_hub.inference._providers._common.BaseConversationalTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.novita.NovitaConversationalTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"_prepare_route":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.novita.NovitaConversationalTask._prepare_route","name":"_prepare_route","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"arg_types":["huggingface_hub.inference._providers.novita.NovitaConversationalTask","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_route of NovitaConversationalTask","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.novita.NovitaConversationalTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.novita.NovitaConversationalTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"NovitaTextGenerationTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.BaseTextGenerationTask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.novita.NovitaTextGenerationTask","name":"NovitaTextGenerationTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.novita.NovitaTextGenerationTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers.novita","mro":["huggingface_hub.inference._providers.novita.NovitaTextGenerationTask","huggingface_hub.inference._providers._common.BaseTextGenerationTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.novita.NovitaTextGenerationTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"_prepare_route":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.novita.NovitaTextGenerationTask._prepare_route","name":"_prepare_route","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"arg_types":["huggingface_hub.inference._providers.novita.NovitaTextGenerationTask","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_route of NovitaTextGenerationTask","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_response":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.novita.NovitaTextGenerationTask.get_response","name":"get_response","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"arg_types":["huggingface_hub.inference._providers.novita.NovitaTextGenerationTask",{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._common.RequestParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_response of NovitaTextGenerationTask","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.novita.NovitaTextGenerationTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.novita.NovitaTextGenerationTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"NovitaTextToVideoTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.TaskProviderHelper"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.novita.NovitaTextToVideoTask","name":"NovitaTextToVideoTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.novita.NovitaTextToVideoTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers.novita","mro":["huggingface_hub.inference._providers.novita.NovitaTextToVideoTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.novita.NovitaTextToVideoTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"_prepare_payload_as_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.novita.NovitaTextToVideoTask._prepare_payload_as_dict","name":"_prepare_payload_as_dict","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"arg_types":["huggingface_hub.inference._providers.novita.NovitaTextToVideoTask",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_dict of NovitaTextToVideoTask","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_route":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.novita.NovitaTextToVideoTask._prepare_route","name":"_prepare_route","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"arg_types":["huggingface_hub.inference._providers.novita.NovitaTextToVideoTask","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_route of NovitaTextToVideoTask","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_response":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.novita.NovitaTextToVideoTask.get_response","name":"get_response","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"arg_types":["huggingface_hub.inference._providers.novita.NovitaTextToVideoTask",{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._common.RequestParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_response of NovitaTextToVideoTask","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.novita.NovitaTextToVideoTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.novita.NovitaTextToVideoTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"RequestParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common.RequestParameters","kind":"Gdef"},"TaskProviderHelper":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.TaskProviderHelper","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"_BASE_URL":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.inference._providers.novita._BASE_URL","name":"_BASE_URL","setter_type":null,"type":"builtins.str"}},"_PROVIDER":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.inference._providers.novita._PROVIDER","name":"_PROVIDER","setter_type":null,"type":"builtins.str"}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.novita.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.novita.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.novita.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.novita.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.novita.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.novita.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_as_dict":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._as_dict","kind":"Gdef"},"filter_none":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.filter_none","kind":"Gdef"},"get_session":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._http.get_session","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/novita.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/novita.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/novita.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..275cd89724b7fbc4db51235cee25f357e9f5f36f --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/novita.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[5,4,3,11,1,1,1,1],"dep_prios":[5,5,5,5,5,5,30,30],"dependencies":["huggingface_hub.inference._providers._common","huggingface_hub.inference._common","huggingface_hub.hf_api","huggingface_hub.utils","typing","builtins","_frozen_importlib","abc"],"hash":"0b78e821fd30614b68a74a06c4cf080e59ced425","id":"huggingface_hub.inference._providers.novita","ignore_all":true,"interface_hash":"b4476ef3977b0c7235add574a04d908590055f40","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/novita.py","plugin_data":null,"size":2508,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/nscale.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/nscale.data.json new file mode 100644 index 0000000000000000000000000000000000000000..6b2c25f18c120e17fdc64010f6d1a5e7207c6c75 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/nscale.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._providers.nscale","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseConversationalTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.BaseConversationalTask","kind":"Gdef"},"InferenceProviderMapping":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.hf_api.InferenceProviderMapping","kind":"Gdef"},"NscaleConversationalTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.BaseConversationalTask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.nscale.NscaleConversationalTask","name":"NscaleConversationalTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.nscale.NscaleConversationalTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers.nscale","mro":["huggingface_hub.inference._providers.nscale.NscaleConversationalTask","huggingface_hub.inference._providers._common.BaseConversationalTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.nscale.NscaleConversationalTask.__init__","name":"__init__","original_first_arg":"self","type":null}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.nscale.NscaleConversationalTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.nscale.NscaleConversationalTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"NscaleTextToImageTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.TaskProviderHelper"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.nscale.NscaleTextToImageTask","name":"NscaleTextToImageTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.nscale.NscaleTextToImageTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers.nscale","mro":["huggingface_hub.inference._providers.nscale.NscaleTextToImageTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.nscale.NscaleTextToImageTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"_prepare_payload_as_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.nscale.NscaleTextToImageTask._prepare_payload_as_dict","name":"_prepare_payload_as_dict","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"arg_types":["huggingface_hub.inference._providers.nscale.NscaleTextToImageTask",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_dict of NscaleTextToImageTask","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_route":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.nscale.NscaleTextToImageTask._prepare_route","name":"_prepare_route","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"arg_types":["huggingface_hub.inference._providers.nscale.NscaleTextToImageTask","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_route of NscaleTextToImageTask","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_response":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.nscale.NscaleTextToImageTask.get_response","name":"get_response","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"arg_types":["huggingface_hub.inference._providers.nscale.NscaleTextToImageTask",{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._common.RequestParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_response of NscaleTextToImageTask","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.nscale.NscaleTextToImageTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.nscale.NscaleTextToImageTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"RequestParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common.RequestParameters","kind":"Gdef"},"TaskProviderHelper":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.TaskProviderHelper","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.nscale.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.nscale.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.nscale.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.nscale.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.nscale.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.nscale.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_as_dict":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._as_dict","kind":"Gdef"},"base64":{".class":"SymbolTableNode","cross_ref":"base64","kind":"Gdef"},"filter_none":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.filter_none","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/nscale.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/nscale.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/nscale.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..6baa6e40a788d7c0ac1d5b4796f43165173d521a --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/nscale.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[7,5,4,1,2,1,1,1],"dep_prios":[5,5,5,10,5,5,30,30],"dependencies":["huggingface_hub.inference._providers._common","huggingface_hub.inference._common","huggingface_hub.hf_api","base64","typing","builtins","_frozen_importlib","abc"],"hash":"13afe7f6bf5d4fd59d20a9ae0dd82d35aa4f30c6","id":"huggingface_hub.inference._providers.nscale","ignore_all":true,"interface_hash":"16c1df1969d37c7056eaf0edd984a5786aa908d8","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/nscale.py","plugin_data":null,"size":1796,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/openai.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/openai.data.json new file mode 100644 index 0000000000000000000000000000000000000000..c6a34d47282911595b7f409b28c1a7479e346771 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/openai.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._providers.openai","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","BaseConversationalTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.BaseConversationalTask","kind":"Gdef"},"InferenceProviderMapping":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.hf_api.InferenceProviderMapping","kind":"Gdef"},"OpenAIConversationalTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.BaseConversationalTask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.openai.OpenAIConversationalTask","name":"OpenAIConversationalTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.openai.OpenAIConversationalTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers.openai","mro":["huggingface_hub.inference._providers.openai.OpenAIConversationalTask","huggingface_hub.inference._providers._common.BaseConversationalTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.openai.OpenAIConversationalTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"_prepare_api_key":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.openai.OpenAIConversationalTask._prepare_api_key","name":"_prepare_api_key","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","api_key"],"arg_types":["huggingface_hub.inference._providers.openai.OpenAIConversationalTask",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_api_key of OpenAIConversationalTask","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_mapping_info":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","model"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.openai.OpenAIConversationalTask._prepare_mapping_info","name":"_prepare_mapping_info","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","model"],"arg_types":["huggingface_hub.inference._providers.openai.OpenAIConversationalTask",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_mapping_info of OpenAIConversationalTask","ret_type":"huggingface_hub.hf_api.InferenceProviderMapping","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.openai.OpenAIConversationalTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.openai.OpenAIConversationalTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.openai.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.openai.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.openai.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.openai.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.openai.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.openai.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/openai.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/openai.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/openai.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..aaf922ef7c87d9ebef515115ae166c6df2197bf4 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/openai.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[4,3,1,1,1,1],"dep_prios":[5,5,5,5,30,30],"dependencies":["huggingface_hub.inference._providers._common","huggingface_hub.hf_api","typing","builtins","_frozen_importlib","abc"],"hash":"4b8614d52f60e6b08152620e8c1863027faaf028","id":"huggingface_hub.inference._providers.openai","ignore_all":true,"interface_hash":"87c0c85057b8fee9d3395c393d115ddb5335895f","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/openai.py","plugin_data":null,"size":1089,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/publicai.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/publicai.data.json new file mode 100644 index 0000000000000000000000000000000000000000..cbc06c5be6dbb9cdcc55722c73c3a925b446857a --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/publicai.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._providers.publicai","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","BaseConversationalTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.BaseConversationalTask","kind":"Gdef"},"PublicAIConversationalTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.BaseConversationalTask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.publicai.PublicAIConversationalTask","name":"PublicAIConversationalTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.publicai.PublicAIConversationalTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers.publicai","mro":["huggingface_hub.inference._providers.publicai.PublicAIConversationalTask","huggingface_hub.inference._providers._common.BaseConversationalTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.publicai.PublicAIConversationalTask.__init__","name":"__init__","original_first_arg":"self","type":null}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.publicai.PublicAIConversationalTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.publicai.PublicAIConversationalTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.publicai.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.publicai.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.publicai.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.publicai.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.publicai.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.publicai.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/publicai.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/publicai.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/publicai.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..cdabfe0b3715f51264818af0f672224d2c0b9f6d --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/publicai.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[1,1,1,1,1],"dep_prios":[5,5,30,30,30],"dependencies":["huggingface_hub.inference._providers._common","builtins","_frozen_importlib","abc","typing"],"hash":"25098525f14a70383a2c8c92b0a5df4f18c4efc0","id":"huggingface_hub.inference._providers.publicai","ignore_all":true,"interface_hash":"743b6835a3d4a352fd8a95aeb39f679deacf1999","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/publicai.py","plugin_data":null,"size":210,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/replicate.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/replicate.data.json new file mode 100644 index 0000000000000000000000000000000000000000..11f0d29b4215de789e33e2938aac9270171adaf0 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/replicate.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._providers.replicate","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"InferenceProviderMapping":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.hf_api.InferenceProviderMapping","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"ReplicateImageToImageTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers.replicate.ReplicateTask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.replicate.ReplicateImageToImageTask","name":"ReplicateImageToImageTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.replicate.ReplicateImageToImageTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers.replicate","mro":["huggingface_hub.inference._providers.replicate.ReplicateImageToImageTask","huggingface_hub.inference._providers.replicate.ReplicateTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.replicate.ReplicateImageToImageTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"_prepare_payload_as_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.replicate.ReplicateImageToImageTask._prepare_payload_as_dict","name":"_prepare_payload_as_dict","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"arg_types":["huggingface_hub.inference._providers.replicate.ReplicateImageToImageTask",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_dict of ReplicateImageToImageTask","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.replicate.ReplicateImageToImageTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.replicate.ReplicateImageToImageTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ReplicateTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.TaskProviderHelper"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.replicate.ReplicateTask","name":"ReplicateTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.replicate.ReplicateTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers.replicate","mro":["huggingface_hub.inference._providers.replicate.ReplicateTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","task"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.replicate.ReplicateTask.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","task"],"arg_types":["huggingface_hub.inference._providers.replicate.ReplicateTask","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of ReplicateTask","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_headers":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","headers","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.replicate.ReplicateTask._prepare_headers","name":"_prepare_headers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","headers","api_key"],"arg_types":["huggingface_hub.inference._providers.replicate.ReplicateTask",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_headers of ReplicateTask","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_payload_as_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.replicate.ReplicateTask._prepare_payload_as_dict","name":"_prepare_payload_as_dict","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"arg_types":["huggingface_hub.inference._providers.replicate.ReplicateTask",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_dict of ReplicateTask","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_route":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.replicate.ReplicateTask._prepare_route","name":"_prepare_route","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"arg_types":["huggingface_hub.inference._providers.replicate.ReplicateTask","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_route of ReplicateTask","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_response":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.replicate.ReplicateTask.get_response","name":"get_response","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"arg_types":["huggingface_hub.inference._providers.replicate.ReplicateTask",{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._common.RequestParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_response of ReplicateTask","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.replicate.ReplicateTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.replicate.ReplicateTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ReplicateTextToImageTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers.replicate.ReplicateTask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.replicate.ReplicateTextToImageTask","name":"ReplicateTextToImageTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.replicate.ReplicateTextToImageTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers.replicate","mro":["huggingface_hub.inference._providers.replicate.ReplicateTextToImageTask","huggingface_hub.inference._providers.replicate.ReplicateTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.replicate.ReplicateTextToImageTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"_prepare_payload_as_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.replicate.ReplicateTextToImageTask._prepare_payload_as_dict","name":"_prepare_payload_as_dict","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"arg_types":["huggingface_hub.inference._providers.replicate.ReplicateTextToImageTask",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_dict of ReplicateTextToImageTask","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.replicate.ReplicateTextToImageTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.replicate.ReplicateTextToImageTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ReplicateTextToSpeechTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers.replicate.ReplicateTask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.replicate.ReplicateTextToSpeechTask","name":"ReplicateTextToSpeechTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.replicate.ReplicateTextToSpeechTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers.replicate","mro":["huggingface_hub.inference._providers.replicate.ReplicateTextToSpeechTask","huggingface_hub.inference._providers.replicate.ReplicateTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.replicate.ReplicateTextToSpeechTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"_prepare_payload_as_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.replicate.ReplicateTextToSpeechTask._prepare_payload_as_dict","name":"_prepare_payload_as_dict","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"arg_types":["huggingface_hub.inference._providers.replicate.ReplicateTextToSpeechTask",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_dict of ReplicateTextToSpeechTask","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.replicate.ReplicateTextToSpeechTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.replicate.ReplicateTextToSpeechTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"RequestParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common.RequestParameters","kind":"Gdef"},"TaskProviderHelper":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.TaskProviderHelper","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"_BASE_URL":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.inference._providers.replicate._BASE_URL","name":"_BASE_URL","setter_type":null,"type":"builtins.str"}},"_PROVIDER":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.inference._providers.replicate._PROVIDER","name":"_PROVIDER","setter_type":null,"type":"builtins.str"}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.replicate.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.replicate.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.replicate.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.replicate.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.replicate.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.replicate.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_as_dict":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._as_dict","kind":"Gdef"},"_as_url":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._as_url","kind":"Gdef"},"filter_none":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.filter_none","kind":"Gdef"},"get_session":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._http.get_session","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/replicate.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/replicate.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/replicate.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..524b18764b16cdd9ce4850b0e586bc7c10e34ea7 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/replicate.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[5,4,3,6,1,1,1,1],"dep_prios":[5,5,5,5,5,5,30,30],"dependencies":["huggingface_hub.inference._providers._common","huggingface_hub.inference._common","huggingface_hub.hf_api","huggingface_hub.utils","typing","builtins","_frozen_importlib","abc"],"hash":"6d713a6904714b7bf68e77675b8074fc4bab8b65","id":"huggingface_hub.inference._providers.replicate","ignore_all":true,"interface_hash":"5564a44b1c46d6470bdab3f54b63c10e805c0726","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/replicate.py","plugin_data":null,"size":3814,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/sambanova.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/sambanova.data.json new file mode 100644 index 0000000000000000000000000000000000000000..3a73a14af4d8bfeaee386811beb71a4b102c4e54 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/sambanova.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._providers.sambanova","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseConversationalTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.BaseConversationalTask","kind":"Gdef"},"InferenceProviderMapping":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.hf_api.InferenceProviderMapping","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"RequestParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common.RequestParameters","kind":"Gdef"},"SambanovaConversationalTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.BaseConversationalTask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.sambanova.SambanovaConversationalTask","name":"SambanovaConversationalTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.sambanova.SambanovaConversationalTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers.sambanova","mro":["huggingface_hub.inference._providers.sambanova.SambanovaConversationalTask","huggingface_hub.inference._providers._common.BaseConversationalTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.sambanova.SambanovaConversationalTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"_prepare_payload_as_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.sambanova.SambanovaConversationalTask._prepare_payload_as_dict","name":"_prepare_payload_as_dict","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"arg_types":["huggingface_hub.inference._providers.sambanova.SambanovaConversationalTask",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_dict of SambanovaConversationalTask","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.sambanova.SambanovaConversationalTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.sambanova.SambanovaConversationalTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"SambanovaFeatureExtractionTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.TaskProviderHelper"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.sambanova.SambanovaFeatureExtractionTask","name":"SambanovaFeatureExtractionTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.sambanova.SambanovaFeatureExtractionTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers.sambanova","mro":["huggingface_hub.inference._providers.sambanova.SambanovaFeatureExtractionTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.sambanova.SambanovaFeatureExtractionTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"_prepare_payload_as_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.sambanova.SambanovaFeatureExtractionTask._prepare_payload_as_dict","name":"_prepare_payload_as_dict","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"arg_types":["huggingface_hub.inference._providers.sambanova.SambanovaFeatureExtractionTask",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_dict of SambanovaFeatureExtractionTask","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_route":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.sambanova.SambanovaFeatureExtractionTask._prepare_route","name":"_prepare_route","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"arg_types":["huggingface_hub.inference._providers.sambanova.SambanovaFeatureExtractionTask","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_route of SambanovaFeatureExtractionTask","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_response":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.sambanova.SambanovaFeatureExtractionTask.get_response","name":"get_response","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"arg_types":["huggingface_hub.inference._providers.sambanova.SambanovaFeatureExtractionTask",{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._common.RequestParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_response of SambanovaFeatureExtractionTask","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.sambanova.SambanovaFeatureExtractionTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.sambanova.SambanovaFeatureExtractionTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TaskProviderHelper":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.TaskProviderHelper","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.sambanova.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.sambanova.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.sambanova.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.sambanova.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.sambanova.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.sambanova.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_as_dict":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._as_dict","kind":"Gdef"},"filter_none":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.filter_none","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/sambanova.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/sambanova.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/sambanova.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..8d004e8505e77e7f45e55caafcd6a594b972f84b --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/sambanova.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[5,4,3,1,1,1,1],"dep_prios":[5,5,5,5,5,30,30],"dependencies":["huggingface_hub.inference._providers._common","huggingface_hub.inference._common","huggingface_hub.hf_api","typing","builtins","_frozen_importlib","abc"],"hash":"0950b300da3bec4f066e91ce304e3d309fd4a8e1","id":"huggingface_hub.inference._providers.sambanova","ignore_all":true,"interface_hash":"ac3f4013fe998681bb5624fc1b1722341f29c45b","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/sambanova.py","plugin_data":null,"size":2031,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/scaleway.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/scaleway.data.json new file mode 100644 index 0000000000000000000000000000000000000000..7895ccb073658e788f9f76c4cae3bc6df46db9c9 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/scaleway.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._providers.scaleway","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseConversationalTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.BaseConversationalTask","kind":"Gdef"},"Dict":{".class":"SymbolTableNode","cross_ref":"typing.Dict","kind":"Gdef"},"InferenceProviderMapping":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.hf_api.InferenceProviderMapping","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"RequestParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common.RequestParameters","kind":"Gdef"},"ScalewayConversationalTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.BaseConversationalTask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.scaleway.ScalewayConversationalTask","name":"ScalewayConversationalTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.scaleway.ScalewayConversationalTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers.scaleway","mro":["huggingface_hub.inference._providers.scaleway.ScalewayConversationalTask","huggingface_hub.inference._providers._common.BaseConversationalTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.scaleway.ScalewayConversationalTask.__init__","name":"__init__","original_first_arg":"self","type":null}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.scaleway.ScalewayConversationalTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.scaleway.ScalewayConversationalTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ScalewayFeatureExtractionTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.TaskProviderHelper"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.scaleway.ScalewayFeatureExtractionTask","name":"ScalewayFeatureExtractionTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.scaleway.ScalewayFeatureExtractionTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers.scaleway","mro":["huggingface_hub.inference._providers.scaleway.ScalewayFeatureExtractionTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.scaleway.ScalewayFeatureExtractionTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"_prepare_payload_as_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.scaleway.ScalewayFeatureExtractionTask._prepare_payload_as_dict","name":"_prepare_payload_as_dict","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"arg_types":["huggingface_hub.inference._providers.scaleway.ScalewayFeatureExtractionTask",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_dict of ScalewayFeatureExtractionTask","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_route":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.scaleway.ScalewayFeatureExtractionTask._prepare_route","name":"_prepare_route","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"arg_types":["huggingface_hub.inference._providers.scaleway.ScalewayFeatureExtractionTask","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_route of ScalewayFeatureExtractionTask","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_response":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.scaleway.ScalewayFeatureExtractionTask.get_response","name":"get_response","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"arg_types":["huggingface_hub.inference._providers.scaleway.ScalewayFeatureExtractionTask",{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._common.RequestParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_response of ScalewayFeatureExtractionTask","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.scaleway.ScalewayFeatureExtractionTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.scaleway.ScalewayFeatureExtractionTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TaskProviderHelper":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.TaskProviderHelper","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.scaleway.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.scaleway.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.scaleway.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.scaleway.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.scaleway.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.scaleway.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_as_dict":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._as_dict","kind":"Gdef"},"filter_none":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.filter_none","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/scaleway.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/scaleway.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/scaleway.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..591cd7d36df987944d117a6214da20c9eeba9ec4 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/scaleway.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[5,3,1,1,1,1,1],"dep_prios":[5,5,5,5,30,30,30],"dependencies":["huggingface_hub.inference._providers._common","huggingface_hub.inference._common","typing","builtins","_frozen_importlib","abc","huggingface_hub.hf_api"],"hash":"90bd3da03e426dead672009576f341e7d62a3eca","id":"huggingface_hub.inference._providers.scaleway","ignore_all":true,"interface_hash":"146b9bb9fdd5dc3fae5d3e418a0c181c78b8c9bc","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/scaleway.py","plugin_data":null,"size":1209,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/together.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/together.data.json new file mode 100644 index 0000000000000000000000000000000000000000..e7e6e5639c8aa087c6ad778215af3458e6646f2a --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/together.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._providers.together","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","ABC":{".class":"SymbolTableNode","cross_ref":"abc.ABC","kind":"Gdef"},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseConversationalTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.BaseConversationalTask","kind":"Gdef"},"BaseTextGenerationTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.BaseTextGenerationTask","kind":"Gdef"},"InferenceProviderMapping":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.hf_api.InferenceProviderMapping","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"RequestParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common.RequestParameters","kind":"Gdef"},"TaskProviderHelper":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.TaskProviderHelper","kind":"Gdef"},"TogetherConversationalTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.BaseConversationalTask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.together.TogetherConversationalTask","name":"TogetherConversationalTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.together.TogetherConversationalTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers.together","mro":["huggingface_hub.inference._providers.together.TogetherConversationalTask","huggingface_hub.inference._providers._common.BaseConversationalTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.together.TogetherConversationalTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"_prepare_payload_as_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.together.TogetherConversationalTask._prepare_payload_as_dict","name":"_prepare_payload_as_dict","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"arg_types":["huggingface_hub.inference._providers.together.TogetherConversationalTask",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_dict of TogetherConversationalTask","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.together.TogetherConversationalTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.together.TogetherConversationalTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TogetherTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.TaskProviderHelper","abc.ABC"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.together.TogetherTask","name":"TogetherTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.together.TogetherTask","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._providers.together","mro":["huggingface_hub.inference._providers.together.TogetherTask","huggingface_hub.inference._providers._common.TaskProviderHelper","abc.ABC","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","task"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.together.TogetherTask.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","task"],"arg_types":["huggingface_hub.inference._providers.together.TogetherTask","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of TogetherTask","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_route":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.together.TogetherTask._prepare_route","name":"_prepare_route","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"arg_types":["huggingface_hub.inference._providers.together.TogetherTask","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_route of TogetherTask","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.together.TogetherTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.together.TogetherTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TogetherTextGenerationTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.BaseTextGenerationTask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.together.TogetherTextGenerationTask","name":"TogetherTextGenerationTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.together.TogetherTextGenerationTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers.together","mro":["huggingface_hub.inference._providers.together.TogetherTextGenerationTask","huggingface_hub.inference._providers._common.BaseTextGenerationTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.together.TogetherTextGenerationTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"get_response":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.together.TogetherTextGenerationTask.get_response","name":"get_response","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"arg_types":["huggingface_hub.inference._providers.together.TogetherTextGenerationTask",{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._common.RequestParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_response of TogetherTextGenerationTask","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.together.TogetherTextGenerationTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.together.TogetherTextGenerationTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TogetherTextToImageTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers.together.TogetherTask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.together.TogetherTextToImageTask","name":"TogetherTextToImageTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.together.TogetherTextToImageTask","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._providers.together","mro":["huggingface_hub.inference._providers.together.TogetherTextToImageTask","huggingface_hub.inference._providers.together.TogetherTask","huggingface_hub.inference._providers._common.TaskProviderHelper","abc.ABC","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.together.TogetherTextToImageTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"_prepare_payload_as_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.together.TogetherTextToImageTask._prepare_payload_as_dict","name":"_prepare_payload_as_dict","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"arg_types":["huggingface_hub.inference._providers.together.TogetherTextToImageTask",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_dict of TogetherTextToImageTask","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_response":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.together.TogetherTextToImageTask.get_response","name":"get_response","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"arg_types":["huggingface_hub.inference._providers.together.TogetherTextToImageTask",{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._common.RequestParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_response of TogetherTextToImageTask","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.together.TogetherTextToImageTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.together.TogetherTextToImageTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"_BASE_URL":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.inference._providers.together._BASE_URL","name":"_BASE_URL","setter_type":null,"type":"builtins.str"}},"_PROVIDER":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.inference._providers.together._PROVIDER","name":"_PROVIDER","setter_type":null,"type":"builtins.str"}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.together.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.together.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.together.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.together.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.together.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.together.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_as_dict":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._as_dict","kind":"Gdef"},"base64":{".class":"SymbolTableNode","cross_ref":"base64","kind":"Gdef"},"filter_none":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.filter_none","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/together.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/together.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/together.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..b69ff4e9d91b3f3f48d15c6fdbd88b7db95a9069 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/together.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[7,6,5,1,2,3,1,1],"dep_prios":[5,5,5,10,5,5,5,30],"dependencies":["huggingface_hub.inference._providers._common","huggingface_hub.inference._common","huggingface_hub.hf_api","base64","abc","typing","builtins","_frozen_importlib"],"hash":"78ded8af2a8e8b970d382af344df4d34d17dac39","id":"huggingface_hub.inference._providers.together","ignore_all":true,"interface_hash":"94a558e02b708914276712c8f1996244b030c56e","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/together.py","plugin_data":null,"size":3433,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/wavespeed.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/wavespeed.data.json new file mode 100644 index 0000000000000000000000000000000000000000..b00592b4c5f89f0e54ec7588597ca1c2a57c9611 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/wavespeed.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._providers.wavespeed","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","ABC":{".class":"SymbolTableNode","cross_ref":"abc.ABC","kind":"Gdef"},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"InferenceProviderMapping":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.hf_api.InferenceProviderMapping","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"RequestParameters":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common.RequestParameters","kind":"Gdef"},"TaskProviderHelper":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.TaskProviderHelper","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"WavespeedAIImageToImageTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers.wavespeed.WavespeedAITask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.wavespeed.WavespeedAIImageToImageTask","name":"WavespeedAIImageToImageTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.wavespeed.WavespeedAIImageToImageTask","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._providers.wavespeed","mro":["huggingface_hub.inference._providers.wavespeed.WavespeedAIImageToImageTask","huggingface_hub.inference._providers.wavespeed.WavespeedAITask","huggingface_hub.inference._providers._common.TaskProviderHelper","abc.ABC","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.wavespeed.WavespeedAIImageToImageTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"_prepare_payload_as_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.wavespeed.WavespeedAIImageToImageTask._prepare_payload_as_dict","name":"_prepare_payload_as_dict","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"arg_types":["huggingface_hub.inference._providers.wavespeed.WavespeedAIImageToImageTask",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_dict of WavespeedAIImageToImageTask","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.wavespeed.WavespeedAIImageToImageTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.wavespeed.WavespeedAIImageToImageTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"WavespeedAIImageToVideoTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers.wavespeed.WavespeedAIImageToImageTask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.wavespeed.WavespeedAIImageToVideoTask","name":"WavespeedAIImageToVideoTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.wavespeed.WavespeedAIImageToVideoTask","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._providers.wavespeed","mro":["huggingface_hub.inference._providers.wavespeed.WavespeedAIImageToVideoTask","huggingface_hub.inference._providers.wavespeed.WavespeedAIImageToImageTask","huggingface_hub.inference._providers.wavespeed.WavespeedAITask","huggingface_hub.inference._providers._common.TaskProviderHelper","abc.ABC","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.wavespeed.WavespeedAIImageToVideoTask.__init__","name":"__init__","original_first_arg":"self","type":null}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.wavespeed.WavespeedAIImageToVideoTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.wavespeed.WavespeedAIImageToVideoTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"WavespeedAITask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.TaskProviderHelper","abc.ABC"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.wavespeed.WavespeedAITask","name":"WavespeedAITask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.wavespeed.WavespeedAITask","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._providers.wavespeed","mro":["huggingface_hub.inference._providers.wavespeed.WavespeedAITask","huggingface_hub.inference._providers._common.TaskProviderHelper","abc.ABC","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","task"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.wavespeed.WavespeedAITask.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","task"],"arg_types":["huggingface_hub.inference._providers.wavespeed.WavespeedAITask","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of WavespeedAITask","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_route":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.wavespeed.WavespeedAITask._prepare_route","name":"_prepare_route","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"arg_types":["huggingface_hub.inference._providers.wavespeed.WavespeedAITask","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_route of WavespeedAITask","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_response":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.wavespeed.WavespeedAITask.get_response","name":"get_response","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","response","request_params"],"arg_types":["huggingface_hub.inference._providers.wavespeed.WavespeedAITask",{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.inference._common.RequestParameters",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_response of WavespeedAITask","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.wavespeed.WavespeedAITask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.wavespeed.WavespeedAITask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"WavespeedAITextToImageTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers.wavespeed.WavespeedAITask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.wavespeed.WavespeedAITextToImageTask","name":"WavespeedAITextToImageTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.wavespeed.WavespeedAITextToImageTask","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._providers.wavespeed","mro":["huggingface_hub.inference._providers.wavespeed.WavespeedAITextToImageTask","huggingface_hub.inference._providers.wavespeed.WavespeedAITask","huggingface_hub.inference._providers._common.TaskProviderHelper","abc.ABC","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.wavespeed.WavespeedAITextToImageTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"_prepare_payload_as_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.wavespeed.WavespeedAITextToImageTask._prepare_payload_as_dict","name":"_prepare_payload_as_dict","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","inputs","parameters","provider_mapping_info"],"arg_types":["huggingface_hub.inference._providers.wavespeed.WavespeedAITextToImageTask",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"huggingface_hub.hf_api.InferenceProviderMapping"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_payload_as_dict of WavespeedAITextToImageTask","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.wavespeed.WavespeedAITextToImageTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.wavespeed.WavespeedAITextToImageTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"WavespeedAITextToVideoTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers.wavespeed.WavespeedAITextToImageTask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.wavespeed.WavespeedAITextToVideoTask","name":"WavespeedAITextToVideoTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.wavespeed.WavespeedAITextToVideoTask","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.inference._providers.wavespeed","mro":["huggingface_hub.inference._providers.wavespeed.WavespeedAITextToVideoTask","huggingface_hub.inference._providers.wavespeed.WavespeedAITextToImageTask","huggingface_hub.inference._providers.wavespeed.WavespeedAITask","huggingface_hub.inference._providers._common.TaskProviderHelper","abc.ABC","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.wavespeed.WavespeedAITextToVideoTask.__init__","name":"__init__","original_first_arg":"self","type":null}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.wavespeed.WavespeedAITextToVideoTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.wavespeed.WavespeedAITextToVideoTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_POLLING_INTERVAL":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.inference._providers.wavespeed._POLLING_INTERVAL","name":"_POLLING_INTERVAL","setter_type":null,"type":"builtins.float"}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.wavespeed.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.wavespeed.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.wavespeed.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.wavespeed.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.wavespeed.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.wavespeed.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_as_dict":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._common._as_dict","kind":"Gdef"},"base64":{".class":"SymbolTableNode","cross_ref":"base64","kind":"Gdef"},"filter_none":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.filter_none","kind":"Gdef"},"get_logger":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils.logging.get_logger","kind":"Gdef"},"get_session":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._http.get_session","kind":"Gdef"},"hf_raise_for_status":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._http.hf_raise_for_status","kind":"Gdef"},"logger":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.inference._providers.wavespeed.logger","name":"logger","setter_type":null,"type":"logging.Logger"}},"time":{".class":"SymbolTableNode","cross_ref":"time","kind":"Gdef"},"urlparse":{".class":"SymbolTableNode","cross_ref":"urllib.parse.urlparse","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/wavespeed.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/wavespeed.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/wavespeed.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..c43793a2dbda6efb19718c4af1ead5087b6fb89f --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/wavespeed.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[9,8,11,5,7,10,1,2,3,4,1,1,1],"dep_prios":[5,5,5,5,5,5,10,10,5,5,5,30,30],"dependencies":["huggingface_hub.inference._providers._common","huggingface_hub.inference._common","huggingface_hub.utils.logging","urllib.parse","huggingface_hub.hf_api","huggingface_hub.utils","base64","time","abc","typing","builtins","_frozen_importlib","logging"],"hash":"4dbf74eeadad274d650c01498b7984da948aad2a","id":"huggingface_hub.inference._providers.wavespeed","ignore_all":true,"interface_hash":"4592d2dc33674f7cbb040b79f4ab0c4af146ff8b","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/wavespeed.py","plugin_data":null,"size":5060,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/zai_org.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/zai_org.data.json new file mode 100644 index 0000000000000000000000000000000000000000..b0f51dc596c0e94d506c4b825e5aacc66bab1287 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/zai_org.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.inference._providers.zai_org","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseConversationalTask":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.inference._providers._common.BaseConversationalTask","kind":"Gdef"},"Dict":{".class":"SymbolTableNode","cross_ref":"typing.Dict","kind":"Gdef"},"ZaiConversationalTask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.inference._providers._common.BaseConversationalTask"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.inference._providers.zai_org.ZaiConversationalTask","name":"ZaiConversationalTask","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.zai_org.ZaiConversationalTask","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.inference._providers.zai_org","mro":["huggingface_hub.inference._providers.zai_org.ZaiConversationalTask","huggingface_hub.inference._providers._common.BaseConversationalTask","huggingface_hub.inference._providers._common.TaskProviderHelper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.inference._providers.zai_org.ZaiConversationalTask.__init__","name":"__init__","original_first_arg":"self","type":null}},"_prepare_headers":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","headers","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.zai_org.ZaiConversationalTask._prepare_headers","name":"_prepare_headers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","headers","api_key"],"arg_types":["huggingface_hub.inference._providers.zai_org.ZaiConversationalTask",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_headers of ZaiConversationalTask","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_route":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.inference._providers.zai_org.ZaiConversationalTask._prepare_route","name":"_prepare_route","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","mapped_model","api_key"],"arg_types":["huggingface_hub.inference._providers.zai_org.ZaiConversationalTask","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_route of ZaiConversationalTask","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.inference._providers.zai_org.ZaiConversationalTask.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.inference._providers.zai_org.ZaiConversationalTask","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.zai_org.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.zai_org.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.zai_org.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.zai_org.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.zai_org.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.inference._providers.zai_org.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/zai_org.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/zai_org.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/zai_org.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..759ec60e76551e55124f5d523d0e04532edaaf7d --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/inference/_providers/zai_org.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[3,1,1,1,1],"dep_prios":[5,5,5,30,30],"dependencies":["huggingface_hub.inference._providers._common","typing","builtins","_frozen_importlib","abc"],"hash":"3e18809f00b1aeae8a5194b84607a4bdfca5d834","id":"huggingface_hub.inference._providers.zai_org","ignore_all":true,"interface_hash":"bb3af4a02f2b8713e1a90778ad4da829af9070b3","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/inference/_providers/zai_org.py","plugin_data":null,"size":646,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/serialization/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/serialization/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..01384ac8fce73b88009d5b31b3333578c003e43c --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/serialization/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.serialization","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","StateDictSplit":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.serialization._base.StateDictSplit","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.serialization.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.serialization.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.serialization.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.serialization.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.serialization.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.serialization.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.serialization.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"get_torch_storage_id":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.serialization._torch.get_torch_storage_id","kind":"Gdef"},"get_torch_storage_size":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.serialization._torch.get_torch_storage_size","kind":"Gdef"},"load_state_dict_from_file":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.serialization._torch.load_state_dict_from_file","kind":"Gdef"},"load_torch_model":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.serialization._torch.load_torch_model","kind":"Gdef"},"save_torch_model":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.serialization._torch.save_torch_model","kind":"Gdef"},"save_torch_state_dict":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.serialization._torch.save_torch_state_dict","kind":"Gdef"},"split_state_dict_into_shards_factory":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.serialization._base.split_state_dict_into_shards_factory","kind":"Gdef"},"split_torch_state_dict_into_shards":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.serialization._torch.split_torch_state_dict_into_shards","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/serialization/__init__.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/serialization/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/serialization/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..da0d97da3f9353ff8297d0b57cb2c4634234c4da --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/serialization/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[17,18,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["huggingface_hub.serialization._base","huggingface_hub.serialization._torch","builtins","_frozen_importlib","abc","typing"],"hash":"ef2488f4b137a5c22ce52c9455c819c9dcc0615a","id":"huggingface_hub.serialization","ignore_all":true,"interface_hash":"a9c4b583b9369010aa35fbddc1f0d932c8d24376","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/serialization/__init__.py","plugin_data":null,"size":963,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/serialization/_base.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/serialization/_base.data.json new file mode 100644 index 0000000000000000000000000000000000000000..6b4ab5db0853ec147f2cacdd1e6136b1ec765134 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/serialization/_base.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.serialization._base","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"MAX_SHARD_SIZE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.serialization._base.MAX_SHARD_SIZE","name":"MAX_SHARD_SIZE","setter_type":null,"type":"builtins.str"}},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"SIZE_UNITS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.serialization._base.SIZE_UNITS","name":"SIZE_UNITS","setter_type":null,"type":{".class":"Instance","args":["builtins.str","builtins.int"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"StateDictSplit":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.serialization._base.StateDictSplit","name":"StateDictSplit","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.serialization._base.StateDictSplit","has_param_spec_type":false,"metaclass_type":null,"metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":40,"name":"is_sharded","type":"builtins.bool"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":41,"name":"metadata","type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":42,"name":"filename_to_tensors","type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"builtins.dict"}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":43,"name":"tensor_to_filename","type":{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}}],"frozen":false},"dataclass_tag":{}},"module_name":"huggingface_hub.serialization._base","mro":["huggingface_hub.serialization._base.StateDictSplit","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"huggingface_hub.serialization._base.StateDictSplit.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"dataclasses.Field"}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","metadata","filename_to_tensors","tensor_to_filename"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.serialization._base.StateDictSplit.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","metadata","filename_to_tensors","tensor_to_filename"],"arg_types":["huggingface_hub.serialization._base.StateDictSplit",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of StateDictSplit","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-post_init":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.serialization._base.StateDictSplit.__mypy-post_init","name":"__mypy-post_init","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.serialization._base.StateDictSplit"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-post_init of StateDictSplit","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5],"arg_names":["is_sharded","metadata","filename_to_tensors","tensor_to_filename"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"huggingface_hub.serialization._base.StateDictSplit.__mypy-replace","name":"__mypy-replace","original_first_arg":"is_sharded","type":{".class":"CallableType","arg_kinds":[5,5,5,5],"arg_names":["is_sharded","metadata","filename_to_tensors","tensor_to_filename"],"arg_types":["builtins.bool",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of StateDictSplit","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"huggingface_hub.serialization._base.StateDictSplit.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5],"arg_names":["is_sharded","metadata","filename_to_tensors","tensor_to_filename"],"arg_types":["builtins.bool",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of StateDictSplit","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"__post_init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.serialization._base.StateDictSplit.__post_init__","name":"__post_init__","original_first_arg":"self","type":null}},"filename_to_tensors":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.serialization._base.StateDictSplit.filename_to_tensors","name":"filename_to_tensors","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"is_sharded":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.serialization._base.StateDictSplit.is_sharded","name":"is_sharded","setter_type":null,"type":"builtins.bool"}},"metadata":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.serialization._base.StateDictSplit.metadata","name":"metadata","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"tensor_to_filename":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.serialization._base.StateDictSplit.tensor_to_filename","name":"tensor_to_filename","setter_type":null,"type":{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.serialization._base.StateDictSplit.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.serialization._base.StateDictSplit","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"StorageIDFn_T":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.serialization._base.TensorT","id":1,"name":"TensorT","namespace":"huggingface_hub.serialization._base.StorageIDFn_T","upper_bound":"builtins.object","values":[],"variance":0}],"column":0,"fullname":"huggingface_hub.serialization._base.StorageIDFn_T","line":24,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.serialization._base.TensorT","id":1,"name":"TensorT","namespace":"huggingface_hub.serialization._base.StorageIDFn_T","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"TensorSizeFn_T":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.serialization._base.TensorT","id":1,"name":"TensorT","namespace":"huggingface_hub.serialization._base.TensorSizeFn_T","upper_bound":"builtins.object","values":[],"variance":0}],"column":0,"fullname":"huggingface_hub.serialization._base.TensorSizeFn_T","line":23,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.serialization._base.TensorT","id":1,"name":"TensorT","namespace":"huggingface_hub.serialization._base.TensorSizeFn_T","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"TensorT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.serialization._base.TensorT","name":"TensorT","upper_bound":"builtins.object","values":[],"variance":0}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.serialization._base.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.serialization._base.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.serialization._base.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.serialization._base.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.serialization._base.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.serialization._base.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"dataclass":{".class":"SymbolTableNode","cross_ref":"dataclasses.dataclass","kind":"Gdef"},"field":{".class":"SymbolTableNode","cross_ref":"dataclasses.field","kind":"Gdef"},"logger":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.serialization._base.logger","name":"logger","setter_type":null,"type":"logging.Logger"}},"logging":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils.logging","kind":"Gdef"},"parse_size_to_int":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["size_as_str"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.serialization._base.parse_size_to_int","name":"parse_size_to_int","original_first_arg":"size_as_str","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["size_as_str"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parse_size_to_int","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"split_state_dict_into_shards_factory":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,3,5,5],"arg_names":["state_dict","get_storage_size","filename_pattern","get_storage_id","max_shard_size"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.serialization._base.split_state_dict_into_shards_factory","name":"split_state_dict_into_shards_factory","original_first_arg":"state_dict","type":{".class":"CallableType","arg_kinds":[0,3,3,5,5],"arg_names":["state_dict","get_storage_size","filename_pattern","get_storage_id","max_shard_size"],"arg_types":[{".class":"Instance","args":["builtins.str",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.serialization._base.TensorT","id":-1,"name":"TensorT","namespace":"huggingface_hub.serialization._base.split_state_dict_into_shards_factory","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"TypeAliasType","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"type_ref":"huggingface_hub.serialization._base.TensorSizeFn_T"},"builtins.str",{".class":"TypeAliasType","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"type_ref":"huggingface_hub.serialization._base.StorageIDFn_T"},{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"split_state_dict_into_shards_factory","ret_type":"huggingface_hub.serialization._base.StateDictSplit","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.serialization._base.TensorT","id":-1,"name":"TensorT","namespace":"huggingface_hub.serialization._base.split_state_dict_into_shards_factory","upper_bound":"builtins.object","values":[],"variance":0}]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/serialization/_base.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/serialization/_base.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/serialization/_base.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..9c34f4d92470b3020c8b635b4c67a855b429d685 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/serialization/_base.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[16,17,19,1,1,1,1,1,1,1],"dep_prios":[5,5,5,5,30,30,30,30,30,30],"dependencies":["dataclasses","typing","huggingface_hub","builtins","_frozen_importlib","abc","enum","huggingface_hub.utils","huggingface_hub.utils.logging","logging"],"hash":"65adc70c4bb31b81bb50ae883b08137f59397efd","id":"huggingface_hub.serialization._base","ignore_all":true,"interface_hash":"ed0886fdfedcfcf22e0bb2ca4a29d0a73d49e308","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/serialization/_base.py","plugin_data":null,"size":8097,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/serialization/_dduf.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/serialization/_dduf.data.json new file mode 100644 index 0000000000000000000000000000000000000000..df88380e92571fffcdd86cc39bbdb6064d446a6f --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/serialization/_dduf.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.serialization._dduf","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"DDUFCorruptedFileError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.DDUFCorruptedFileError","kind":"Gdef"},"DDUFEntry":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.serialization._dduf.DDUFEntry","name":"DDUFEntry","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.serialization._dduf.DDUFEntry","has_param_spec_type":false,"metaclass_type":null,"metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":51,"name":"filename","type":"builtins.str"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":52,"name":"length","type":"builtins.int"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":53,"name":"offset","type":"builtins.int"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":55,"name":"dduf_path","type":"pathlib.Path"}],"frozen":false},"dataclass_tag":{}},"module_name":"huggingface_hub.serialization._dduf","mro":["huggingface_hub.serialization._dduf.DDUFEntry","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"huggingface_hub.serialization._dduf.DDUFEntry.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"dataclasses.Field"}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0],"arg_names":["self","filename","length","offset","dduf_path"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.serialization._dduf.DDUFEntry.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":["self","filename","length","offset","dduf_path"],"arg_types":["huggingface_hub.serialization._dduf.DDUFEntry","builtins.str","builtins.int","builtins.int","pathlib.Path"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of DDUFEntry","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5],"arg_names":["filename","length","offset","dduf_path"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"huggingface_hub.serialization._dduf.DDUFEntry.__mypy-replace","name":"__mypy-replace","original_first_arg":"filename","type":{".class":"CallableType","arg_kinds":[5,5,5,5],"arg_names":["filename","length","offset","dduf_path"],"arg_types":["builtins.str","builtins.int","builtins.int","pathlib.Path"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of DDUFEntry","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"huggingface_hub.serialization._dduf.DDUFEntry.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5],"arg_names":["filename","length","offset","dduf_path"],"arg_types":["builtins.str","builtins.int","builtins.int","pathlib.Path"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of DDUFEntry","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"as_mmap":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated","is_trivial_self"],"fullname":"huggingface_hub.serialization._dduf.DDUFEntry.as_mmap","name":"as_mmap","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.serialization._dduf.DDUFEntry"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_mmap of DDUFEntry","ret_type":{".class":"Instance","args":["builtins.bytes",{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Generator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred"],"fullname":"huggingface_hub.serialization._dduf.DDUFEntry.as_mmap","name":"as_mmap","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.serialization._dduf.DDUFEntry"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_mmap of DDUFEntry","ret_type":{".class":"Instance","args":["builtins.bytes",{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"dduf_path":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.serialization._dduf.DDUFEntry.dduf_path","name":"dduf_path","setter_type":null,"type":"pathlib.Path"}},"filename":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.serialization._dduf.DDUFEntry.filename","name":"filename","setter_type":null,"type":"builtins.str"}},"length":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.serialization._dduf.DDUFEntry.length","name":"length","setter_type":null,"type":"builtins.int"}},"offset":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.serialization._dduf.DDUFEntry.offset","name":"offset","setter_type":null,"type":"builtins.int"}},"read_text":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","encoding"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.serialization._dduf.DDUFEntry.read_text","name":"read_text","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","encoding"],"arg_types":["huggingface_hub.serialization._dduf.DDUFEntry","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"read_text of DDUFEntry","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.serialization._dduf.DDUFEntry.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.serialization._dduf.DDUFEntry","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"DDUFExportError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.DDUFExportError","kind":"Gdef"},"DDUFInvalidEntryNameError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.DDUFInvalidEntryNameError","kind":"Gdef"},"DDUF_ALLOWED_ENTRIES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.serialization._dduf.DDUF_ALLOWED_ENTRIES","name":"DDUF_ALLOWED_ENTRIES","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"DDUF_FOLDER_REQUIRED_ENTRIES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.serialization._dduf.DDUF_FOLDER_REQUIRED_ENTRIES","name":"DDUF_FOLDER_REQUIRED_ENTRIES","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"Generator":{".class":"SymbolTableNode","cross_ref":"typing.Generator","kind":"Gdef"},"Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef"},"Path":{".class":"SymbolTableNode","cross_ref":"pathlib.Path","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.serialization._dduf.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.serialization._dduf.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.serialization._dduf.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.serialization._dduf.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.serialization._dduf.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.serialization._dduf.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_dump_content_in_archive":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["archive","filename","content"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.serialization._dduf._dump_content_in_archive","name":"_dump_content_in_archive","original_first_arg":"archive","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["archive","filename","content"],"arg_types":["zipfile.ZipFile","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"os.PathLike"},"builtins.bytes"],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_dump_content_in_archive","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_get_data_offset":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["zf","info"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.serialization._dduf._get_data_offset","name":"_get_data_offset","original_first_arg":"zf","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["zf","info"],"arg_types":["zipfile.ZipFile","zipfile.ZipInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_data_offset","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_load_content":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["content"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.serialization._dduf._load_content","name":"_load_content","original_first_arg":"content","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["content"],"arg_types":[{".class":"UnionType","items":["builtins.str","pathlib.Path","builtins.bytes"],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_load_content","ret_type":"builtins.bytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_validate_dduf_entry_name":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["entry_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.serialization._dduf._validate_dduf_entry_name","name":"_validate_dduf_entry_name","original_first_arg":"entry_name","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["entry_name"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_validate_dduf_entry_name","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_validate_dduf_structure":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["index","entry_names"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.serialization._dduf._validate_dduf_structure","name":"_validate_dduf_structure","original_first_arg":"index","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["index","entry_names"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_validate_dduf_structure","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"contextmanager":{".class":"SymbolTableNode","cross_ref":"contextlib.contextmanager","kind":"Gdef"},"dataclass":{".class":"SymbolTableNode","cross_ref":"dataclasses.dataclass","kind":"Gdef"},"export_entries_as_dduf":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["dduf_path","entries"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.serialization._dduf.export_entries_as_dduf","name":"export_entries_as_dduf","original_first_arg":"dduf_path","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["dduf_path","entries"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"os.PathLike"}],"uses_pep604_syntax":false},{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.str",{".class":"UnionType","items":["builtins.str","pathlib.Path","builtins.bytes"],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"export_entries_as_dduf","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"export_folder_as_dduf":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["dduf_path","folder_path"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.serialization._dduf.export_folder_as_dduf","name":"export_folder_as_dduf","original_first_arg":"dduf_path","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["dduf_path","folder_path"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"os.PathLike"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"os.PathLike"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"export_folder_as_dduf","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"field":{".class":"SymbolTableNode","cross_ref":"dataclasses.field","kind":"Gdef"},"json":{".class":"SymbolTableNode","cross_ref":"json","kind":"Gdef"},"logger":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.serialization._dduf.logger","name":"logger","setter_type":null,"type":"logging.Logger"}},"logging":{".class":"SymbolTableNode","cross_ref":"logging","kind":"Gdef"},"mmap":{".class":"SymbolTableNode","cross_ref":"mmap","kind":"Gdef"},"os":{".class":"SymbolTableNode","cross_ref":"os","kind":"Gdef"},"read_dduf_file":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["dduf_path"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.serialization._dduf.read_dduf_file","name":"read_dduf_file","original_first_arg":"dduf_path","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dduf_path"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"os.PathLike"},"builtins.str"],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"read_dduf_file","ret_type":{".class":"Instance","args":["builtins.str","huggingface_hub.serialization._dduf.DDUFEntry"],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"shutil":{".class":"SymbolTableNode","cross_ref":"shutil","kind":"Gdef"},"zipfile":{".class":"SymbolTableNode","cross_ref":"zipfile","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/serialization/_dduf.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/serialization/_dduf.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/serialization/_dduf.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..cb8b1263210c088f3bbd3f825211dc1f0a7edbf5 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/serialization/_dduf.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106718,"dep_lines":[12,1,2,3,4,5,6,7,8,9,10,1,1,1,1],"dep_prios":[5,10,10,10,10,10,10,5,5,5,5,5,30,30,30],"dependencies":["huggingface_hub.errors","json","logging","mmap","os","shutil","zipfile","contextlib","dataclasses","pathlib","typing","builtins","_frozen_importlib","abc","enum"],"hash":"ec0b4696a056f1ebc3f4295d6439184841d83688","id":"huggingface_hub.serialization._dduf","ignore_all":true,"interface_hash":"9e28ea782f17ae8a59efbc25eb4c87aefdddc6dc","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/serialization/_dduf.py","plugin_data":null,"size":15410,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/serialization/_torch.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/serialization/_torch.data.json new file mode 100644 index 0000000000000000000000000000000000000000..4ca6f4adcd497df18e77698dac336d748b0a94d6 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/serialization/_torch.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.serialization._torch","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"IncompatibleKeys@1003":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.serialization._torch.IncompatibleKeys@1003","name":"IncompatibleKeys@1003","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_named_tuple"],"fullname":"huggingface_hub.serialization._torch.IncompatibleKeys@1003","has_param_spec_type":false,"metaclass_type":null,"metadata":{"namedtuple":{"fields":["missing_keys","unexpected_keys"]}},"module_name":"huggingface_hub.serialization._torch","mro":["huggingface_hub.serialization._torch.IncompatibleKeys@1003","builtins.tuple","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","_NT":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.serialization._torch.IncompatibleKeys@1003._NT","name":"_NT","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},"__annotations__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.serialization._torch.IncompatibleKeys@1003.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.serialization._torch.IncompatibleKeys@1003.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__new__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["_cls","missing_keys","unexpected_keys"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static"],"fullname":"huggingface_hub.serialization._torch.IncompatibleKeys@1003.__new__","name":"__new__","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["_cls","missing_keys","unexpected_keys"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.serialization._torch.IncompatibleKeys@1003._NT","id":-1,"name":"_NT","namespace":"huggingface_hub.serialization._torch.IncompatibleKeys@1003.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of IncompatibleKeys@1003","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.serialization._torch.IncompatibleKeys@1003._NT","id":-1,"name":"_NT","namespace":"huggingface_hub.serialization._torch.IncompatibleKeys@1003.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.serialization._torch.IncompatibleKeys@1003._NT","id":-1,"name":"_NT","namespace":"huggingface_hub.serialization._torch.IncompatibleKeys@1003.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_asdict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["_self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.serialization._torch.IncompatibleKeys@1003._asdict","name":"_asdict","original_first_arg":"_self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["_self"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.serialization._torch.IncompatibleKeys@1003._NT","id":-1,"name":"_NT","namespace":"huggingface_hub.serialization._torch.IncompatibleKeys@1003._asdict","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_asdict of IncompatibleKeys@1003","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.serialization._torch.IncompatibleKeys@1003._NT","id":-1,"name":"_NT","namespace":"huggingface_hub.serialization._torch.IncompatibleKeys@1003._asdict","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_field_defaults":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.serialization._torch.IncompatibleKeys@1003._field_defaults","name":"_field_defaults","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_field_types":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.serialization._torch.IncompatibleKeys@1003._field_types","name":"_field_types","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_fields":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.serialization._torch.IncompatibleKeys@1003._fields","name":"_fields","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_make":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["_cls","iterable"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated"],"fullname":"huggingface_hub.serialization._torch.IncompatibleKeys@1003._make","name":"_make","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["_cls","iterable"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.serialization._torch.IncompatibleKeys@1003._NT","id":-1,"name":"_NT","namespace":"huggingface_hub.serialization._torch.IncompatibleKeys@1003._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_make of IncompatibleKeys@1003","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.serialization._torch.IncompatibleKeys@1003._NT","id":-1,"name":"_NT","namespace":"huggingface_hub.serialization._torch.IncompatibleKeys@1003._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.serialization._torch.IncompatibleKeys@1003._NT","id":-1,"name":"_NT","namespace":"huggingface_hub.serialization._torch.IncompatibleKeys@1003._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_classmethod","is_ready"],"fullname":"huggingface_hub.serialization._torch.IncompatibleKeys@1003._make","name":"_make","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["_cls","iterable"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.serialization._torch.IncompatibleKeys@1003._NT","id":-1,"name":"_NT","namespace":"huggingface_hub.serialization._torch.IncompatibleKeys@1003._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_make of IncompatibleKeys@1003","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.serialization._torch.IncompatibleKeys@1003._NT","id":-1,"name":"_NT","namespace":"huggingface_hub.serialization._torch.IncompatibleKeys@1003._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.serialization._torch.IncompatibleKeys@1003._NT","id":-1,"name":"_NT","namespace":"huggingface_hub.serialization._torch.IncompatibleKeys@1003._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}}},"plugin_generated":true},"_replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5],"arg_names":["_self","missing_keys","unexpected_keys"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.serialization._torch.IncompatibleKeys@1003._replace","name":"_replace","original_first_arg":"_self","type":{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":["_self","missing_keys","unexpected_keys"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.serialization._torch.IncompatibleKeys@1003._NT","id":-1,"name":"_NT","namespace":"huggingface_hub.serialization._torch.IncompatibleKeys@1003._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_replace of IncompatibleKeys@1003","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.serialization._torch.IncompatibleKeys@1003._NT","id":-1,"name":"_NT","namespace":"huggingface_hub.serialization._torch.IncompatibleKeys@1003._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.serialization._torch.IncompatibleKeys@1003._NT","id":-1,"name":"_NT","namespace":"huggingface_hub.serialization._torch.IncompatibleKeys@1003._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_source":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.serialization._torch.IncompatibleKeys@1003._source","name":"_source","setter_type":null,"type":"builtins.str"}},"missing_keys":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"huggingface_hub.serialization._torch.IncompatibleKeys@1003.missing_keys","name":"missing_keys","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}}},"unexpected_keys":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"huggingface_hub.serialization._torch.IncompatibleKeys@1003.unexpected_keys","name":"unexpected_keys","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}}}},"self_type":null,"slots":null,"tuple_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_vars":[],"typeddict_type":null}},"Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef"},"MAX_SHARD_SIZE":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.serialization._base.MAX_SHARD_SIZE","kind":"Gdef"},"NamedTuple":{".class":"SymbolTableNode","cross_ref":"typing.NamedTuple","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"Path":{".class":"SymbolTableNode","cross_ref":"pathlib.Path","kind":"Gdef"},"StateDictSplit":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.serialization._base.StateDictSplit","kind":"Gdef"},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"_IncompatibleKeys":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["huggingface_hub.serialization._torch.IncompatibleKeys@1003"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.serialization._torch._IncompatibleKeys","name":"_IncompatibleKeys","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.serialization._torch._IncompatibleKeys","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.serialization._torch","mro":["huggingface_hub.serialization._torch._IncompatibleKeys","huggingface_hub.serialization._torch.IncompatibleKeys@1003","builtins.tuple","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.serialization._torch._IncompatibleKeys.__repr__","name":"__repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"partial_fallback":"huggingface_hub.serialization._torch._IncompatibleKeys"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr__ of _IncompatibleKeys","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__str__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.serialization._torch._IncompatibleKeys.__str__","name":"__str__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"partial_fallback":"huggingface_hub.serialization._torch._IncompatibleKeys"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.serialization._torch._IncompatibleKeys.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"partial_fallback":"huggingface_hub.serialization._torch._IncompatibleKeys"},"values":[],"variance":0},"slots":null,"tuple_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"partial_fallback":"huggingface_hub.serialization._torch.IncompatibleKeys@1003"},"type_vars":[],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.serialization._torch.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.serialization._torch.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.serialization._torch.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.serialization._torch.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.serialization._torch.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.serialization._torch.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_clean_state_dict_for_safetensors":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["state_dict","metadata","force_contiguous","shared_tensors_to_discard"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.serialization._torch._clean_state_dict_for_safetensors","name":"_clean_state_dict_for_safetensors","original_first_arg":"state_dict","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["state_dict","metadata","force_contiguous","shared_tensors_to_discard"],"arg_types":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":"huggingface_hub.serialization._torch.torch","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.bool",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_clean_state_dict_for_safetensors","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_end_ptr":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["tensor"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.serialization._torch._end_ptr","name":"_end_ptr","original_first_arg":"tensor","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["tensor"],"arg_types":[{".class":"AnyType","missing_import_name":"huggingface_hub.serialization._torch.torch","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_end_ptr","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_filter_shared_not_shared":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["tensors","state_dict"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.serialization._torch._filter_shared_not_shared","name":"_filter_shared_not_shared","original_first_arg":"tensors","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["tensors","state_dict"],"arg_types":[{".class":"Instance","args":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":"huggingface_hub.serialization._torch.torch","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_filter_shared_not_shared","ret_type":{".class":"Instance","args":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_find_shared_tensors":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["state_dict"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.serialization._torch._find_shared_tensors","name":"_find_shared_tensors","original_first_arg":"state_dict","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["state_dict"],"arg_types":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":"huggingface_hub.serialization._torch.torch","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_find_shared_tensors","ret_type":{".class":"Instance","args":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_get_dtype_size":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated"],"fullname":"huggingface_hub.serialization._torch._get_dtype_size","name":"_get_dtype_size","original_first_arg":"dtype","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"huggingface_hub.serialization._torch.torch","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_dtype_size","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.serialization._torch._get_dtype_size","name":"_get_dtype_size","setter_type":null,"type":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"functools._lru_cache_wrapper"}}}},"_get_unique_id":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["tensor"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.serialization._torch._get_unique_id","name":"_get_unique_id","original_first_arg":"tensor","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["tensor"],"arg_types":[{".class":"AnyType","missing_import_name":"huggingface_hub.serialization._torch.torch","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_unique_id","ret_type":{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_is_complete":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["tensor"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.serialization._torch._is_complete","name":"_is_complete","original_first_arg":"tensor","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["tensor"],"arg_types":[{".class":"AnyType","missing_import_name":"huggingface_hub.serialization._torch.torch","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_is_complete","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_load_sharded_checkpoint":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5],"arg_names":["model","save_directory","strict","weights_only","filename_pattern"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.serialization._torch._load_sharded_checkpoint","name":"_load_sharded_checkpoint","original_first_arg":"model","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5],"arg_names":["model","save_directory","strict","weights_only","filename_pattern"],"arg_types":[{".class":"AnyType","missing_import_name":"huggingface_hub.serialization._torch.torch","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"os.PathLike"},"builtins.bool","builtins.bool","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_load_sharded_checkpoint","ret_type":"typing.NamedTuple","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_remove_duplicate_names":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5],"arg_names":["state_dict","preferred_names","discard_names"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.serialization._torch._remove_duplicate_names","name":"_remove_duplicate_names","original_first_arg":"state_dict","type":{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":["state_dict","preferred_names","discard_names"],"arg_types":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":"huggingface_hub.serialization._torch.torch","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_remove_duplicate_names","ret_type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_validate_keys_for_strict_loading":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["model","loaded_keys"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.serialization._torch._validate_keys_for_strict_loading","name":"_validate_keys_for_strict_loading","original_first_arg":"model","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["model","loaded_keys"],"arg_types":[{".class":"AnyType","missing_import_name":"huggingface_hub.serialization._torch.torch","source_any":null,"type_of_any":3},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_validate_keys_for_strict_loading","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"constants":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.constants","kind":"Gdef"},"defaultdict":{".class":"SymbolTableNode","cross_ref":"collections.defaultdict","kind":"Gdef"},"get_torch_storage_id":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["tensor"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.serialization._torch.get_torch_storage_id","name":"get_torch_storage_id","original_first_arg":"tensor","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["tensor"],"arg_types":[{".class":"AnyType","missing_import_name":"huggingface_hub.serialization._torch.torch","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_torch_storage_id","ret_type":{".class":"UnionType","items":[{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"huggingface_hub.serialization._torch.torch","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":false},"builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_torch_storage_size":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["tensor"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.serialization._torch.get_torch_storage_size","name":"get_torch_storage_size","original_first_arg":"tensor","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["tensor"],"arg_types":[{".class":"AnyType","missing_import_name":"huggingface_hub.serialization._torch.torch","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_torch_storage_size","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"importlib":{".class":"SymbolTableNode","cross_ref":"importlib","kind":"Gdef"},"is_torch_tpu_available":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1],"arg_names":["check_device"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated"],"fullname":"huggingface_hub.serialization._torch.is_torch_tpu_available","name":"is_torch_tpu_available","original_first_arg":"check_device","type":null},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.serialization._torch.is_torch_tpu_available","name":"is_torch_tpu_available","setter_type":null,"type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_of_any":7}],"extra_attrs":null,"type_ref":"functools._lru_cache_wrapper"}}}},"json":{".class":"SymbolTableNode","cross_ref":"json","kind":"Gdef"},"load_state_dict_from_file":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["checkpoint_file","map_location","weights_only","mmap"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.serialization._torch.load_state_dict_from_file","name":"load_state_dict_from_file","original_first_arg":"checkpoint_file","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["checkpoint_file","map_location","weights_only","mmap"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"os.PathLike"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"huggingface_hub.serialization._torch.torch","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"load_state_dict_from_file","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":"huggingface_hub.serialization._torch.torch","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"load_torch_model":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5,5],"arg_names":["model","checkpoint_path","strict","safe","weights_only","map_location","mmap","filename_pattern"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.serialization._torch.load_torch_model","name":"load_torch_model","original_first_arg":"model","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5],"arg_names":["model","checkpoint_path","strict","safe","weights_only","map_location","mmap","filename_pattern"],"arg_types":[{".class":"AnyType","missing_import_name":"huggingface_hub.serialization._torch.torch","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"os.PathLike"}],"uses_pep604_syntax":false},"builtins.bool","builtins.bool","builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"huggingface_hub.serialization._torch.torch","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"load_torch_model","ret_type":"typing.NamedTuple","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"logger":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.serialization._torch.logger","name":"logger","setter_type":null,"type":"logging.Logger"}},"logging":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils.logging","kind":"Gdef"},"lru_cache":{".class":"SymbolTableNode","cross_ref":"functools.lru_cache","kind":"Gdef"},"namedtuple":{".class":"SymbolTableNode","cross_ref":"collections.namedtuple","kind":"Gdef"},"os":{".class":"SymbolTableNode","cross_ref":"os","kind":"Gdef"},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef"},"save_torch_model":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5,5,5],"arg_names":["model","save_directory","filename_pattern","force_contiguous","max_shard_size","metadata","safe_serialization","is_main_process","shared_tensors_to_discard"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.serialization._torch.save_torch_model","name":"save_torch_model","original_first_arg":"model","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5],"arg_names":["model","save_directory","filename_pattern","force_contiguous","max_shard_size","metadata","safe_serialization","is_main_process","shared_tensors_to_discard"],"arg_types":[{".class":"AnyType","missing_import_name":"huggingface_hub.serialization._torch.torch","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str","pathlib.Path"],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool",{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool","builtins.bool",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"save_torch_model","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"save_torch_state_dict":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5,5,5],"arg_names":["state_dict","save_directory","filename_pattern","force_contiguous","max_shard_size","metadata","safe_serialization","is_main_process","shared_tensors_to_discard"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.serialization._torch.save_torch_state_dict","name":"save_torch_state_dict","original_first_arg":"state_dict","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5],"arg_names":["state_dict","save_directory","filename_pattern","force_contiguous","max_shard_size","metadata","safe_serialization","is_main_process","shared_tensors_to_discard"],"arg_types":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":"huggingface_hub.serialization._torch.torch","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"UnionType","items":["builtins.str","pathlib.Path"],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool",{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool","builtins.bool",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"save_torch_state_dict","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"split_state_dict_into_shards_factory":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.serialization._base.split_state_dict_into_shards_factory","kind":"Gdef"},"split_torch_state_dict_into_shards":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5],"arg_names":["state_dict","filename_pattern","max_shard_size"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.serialization._torch.split_torch_state_dict_into_shards","name":"split_torch_state_dict_into_shards","original_first_arg":"state_dict","type":{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":["state_dict","filename_pattern","max_shard_size"],"arg_types":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":"huggingface_hub.serialization._torch.torch","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.str",{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"split_torch_state_dict_into_shards","ret_type":"huggingface_hub.serialization._base.StateDictSplit","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"storage_ptr":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["tensor"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.serialization._torch.storage_ptr","name":"storage_ptr","original_first_arg":"tensor","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["tensor"],"arg_types":[{".class":"AnyType","missing_import_name":"huggingface_hub.serialization._torch.torch","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"storage_ptr","ret_type":{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"torch":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"huggingface_hub.serialization._torch.torch","name":"torch","setter_type":null,"type":{".class":"AnyType","missing_import_name":"huggingface_hub.serialization._torch.torch","source_any":null,"type_of_any":3}}},"version":{".class":"SymbolTableNode","cross_ref":"packaging.version","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/serialization/_torch.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/serialization/_torch.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/serialization/_torch.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..6bdffe23b52a04c1b9523a38898dfdae100ec301 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/serialization/_torch.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[28,25,27,16,17,18,19,20,21,22,23,25,27,1,1,1,1,1,1,34],"dep_prios":[5,10,10,10,10,10,10,5,5,5,5,20,5,5,30,30,30,30,30,25],"dependencies":["huggingface_hub.serialization._base","packaging.version","huggingface_hub.constants","importlib","json","os","re","collections","functools","pathlib","typing","packaging","huggingface_hub","builtins","_frozen_importlib","abc","huggingface_hub.utils","huggingface_hub.utils.logging","logging"],"hash":"c6e3a674276ee010e7cf213bfaf449a7802b7e43","id":"huggingface_hub.serialization._torch","ignore_all":true,"interface_hash":"dd77ae072471cda99ab3b7b137d278fd9acd54cd","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/serialization/_torch.py","plugin_data":null,"size":45124,"suppressed":["torch"],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..133e2ad0ce7a62bbe321859bf1ce3ef574ae3652 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.utils","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","ANSI":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._terminal.ANSI","kind":"Gdef"},"ASYNC_CLIENT_FACTORY_T":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._http.ASYNC_CLIENT_FACTORY_T","kind":"Gdef"},"BadRequestError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.BadRequestError","kind":"Gdef"},"CLIENT_FACTORY_T":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._http.CLIENT_FACTORY_T","kind":"Gdef"},"CacheNotFound":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.CacheNotFound","kind":"Gdef"},"CachedFileInfo":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._cache_manager.CachedFileInfo","kind":"Gdef"},"CachedRepoInfo":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._cache_manager.CachedRepoInfo","kind":"Gdef"},"CachedRevisionInfo":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._cache_manager.CachedRevisionInfo","kind":"Gdef"},"CorruptedCacheException":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.CorruptedCacheException","kind":"Gdef"},"DEFAULT_IGNORE_PATTERNS":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._paths.DEFAULT_IGNORE_PATTERNS","kind":"Gdef"},"DeleteCacheStrategy":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._cache_manager.DeleteCacheStrategy","kind":"Gdef"},"DisabledRepoError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.DisabledRepoError","kind":"Gdef"},"EntryNotFoundError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.EntryNotFoundError","kind":"Gdef"},"FORBIDDEN_FOLDERS":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._paths.FORBIDDEN_FOLDERS","kind":"Gdef"},"FileMetadataError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.FileMetadataError","kind":"Gdef"},"GatedRepoError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.GatedRepoError","kind":"Gdef"},"HFCacheInfo":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._cache_manager.HFCacheInfo","kind":"Gdef"},"HFValidationError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.HFValidationError","kind":"Gdef"},"HfHubHTTPError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.HfHubHTTPError","kind":"Gdef"},"LocalEntryNotFoundError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.LocalEntryNotFoundError","kind":"Gdef"},"LocalTokenNotFoundError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.LocalTokenNotFoundError","kind":"Gdef"},"NotASafetensorsRepoError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.NotASafetensorsRepoError","kind":"Gdef"},"OfflineModeIsEnabled":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.OfflineModeIsEnabled","kind":"Gdef"},"RepositoryNotFoundError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.RepositoryNotFoundError","kind":"Gdef"},"RevisionNotFoundError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.RevisionNotFoundError","kind":"Gdef"},"SafetensorsFileMetadata":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._safetensors.SafetensorsFileMetadata","kind":"Gdef"},"SafetensorsParsingError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.SafetensorsParsingError","kind":"Gdef"},"SafetensorsRepoMetadata":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._safetensors.SafetensorsRepoMetadata","kind":"Gdef"},"SoftTemporaryDirectory":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._fixes.SoftTemporaryDirectory","kind":"Gdef"},"TensorInfo":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._safetensors.TensorInfo","kind":"Gdef"},"WeakFileLock":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._fixes.WeakFileLock","kind":"Gdef"},"XetConnectionInfo":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._xet.XetConnectionInfo","kind":"Gdef"},"XetFileData":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._xet.XetFileData","kind":"Gdef"},"XetTokenType":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._xet.XetTokenType","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_format_size":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._cache_manager._format_size","kind":"Gdef"},"_tqdm":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils.tqdm","kind":"Gdef"},"are_progress_bars_disabled":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils.tqdm.are_progress_bars_disabled","kind":"Gdef"},"build_hf_headers":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._headers.build_hf_headers","kind":"Gdef"},"cached_assets_path":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._cache_assets.cached_assets_path","kind":"Gdef"},"capture_output":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._subprocess.capture_output","kind":"Gdef"},"chunk_iterable":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._chunk_utils.chunk_iterable","kind":"Gdef"},"close_session":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._http.close_session","kind":"Gdef"},"disable_progress_bars":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils.tqdm.disable_progress_bars","kind":"Gdef"},"dump_environment_info":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.dump_environment_info","kind":"Gdef"},"enable_progress_bars":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils.tqdm.enable_progress_bars","kind":"Gdef"},"experimental":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._experimental.experimental","kind":"Gdef"},"fetch_xet_connection_info_from_repo_info":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._xet.fetch_xet_connection_info_from_repo_info","kind":"Gdef"},"filter_repo_objects":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._paths.filter_repo_objects","kind":"Gdef"},"fix_hf_endpoint_in_url":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._http.fix_hf_endpoint_in_url","kind":"Gdef"},"get_aiohttp_version":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.get_aiohttp_version","kind":"Gdef"},"get_async_session":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._http.get_async_session","kind":"Gdef"},"get_fastai_version":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.get_fastai_version","kind":"Gdef"},"get_fastapi_version":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.get_fastapi_version","kind":"Gdef"},"get_fastcore_version":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.get_fastcore_version","kind":"Gdef"},"get_gradio_version":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.get_gradio_version","kind":"Gdef"},"get_graphviz_version":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.get_graphviz_version","kind":"Gdef"},"get_hf_hub_version":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.get_hf_hub_version","kind":"Gdef"},"get_jinja_version":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.get_jinja_version","kind":"Gdef"},"get_numpy_version":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.get_numpy_version","kind":"Gdef"},"get_pillow_version":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.get_pillow_version","kind":"Gdef"},"get_pydantic_version":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.get_pydantic_version","kind":"Gdef"},"get_pydot_version":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.get_pydot_version","kind":"Gdef"},"get_python_version":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.get_python_version","kind":"Gdef"},"get_session":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._http.get_session","kind":"Gdef"},"get_stored_tokens":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._auth.get_stored_tokens","kind":"Gdef"},"get_tensorboard_version":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.get_tensorboard_version","kind":"Gdef"},"get_tf_version":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.get_tf_version","kind":"Gdef"},"get_token":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._auth.get_token","kind":"Gdef"},"get_token_to_send":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._headers.get_token_to_send","kind":"Gdef"},"get_torch_version":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.get_torch_version","kind":"Gdef"},"hf_raise_for_status":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._http.hf_raise_for_status","kind":"Gdef"},"http_backoff":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._http.http_backoff","kind":"Gdef"},"http_stream_backoff":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._http.http_stream_backoff","kind":"Gdef"},"installation_method":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.installation_method","kind":"Gdef"},"is_aiohttp_available":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.is_aiohttp_available","kind":"Gdef"},"is_colab_enterprise":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.is_colab_enterprise","kind":"Gdef"},"is_fastai_available":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.is_fastai_available","kind":"Gdef"},"is_fastapi_available":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.is_fastapi_available","kind":"Gdef"},"is_fastcore_available":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.is_fastcore_available","kind":"Gdef"},"is_google_colab":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.is_google_colab","kind":"Gdef"},"is_gradio_available":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.is_gradio_available","kind":"Gdef"},"is_graphviz_available":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.is_graphviz_available","kind":"Gdef"},"is_jinja_available":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.is_jinja_available","kind":"Gdef"},"is_jsonable":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._typing.is_jsonable","kind":"Gdef"},"is_notebook":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.is_notebook","kind":"Gdef"},"is_numpy_available":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.is_numpy_available","kind":"Gdef"},"is_package_available":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.is_package_available","kind":"Gdef"},"is_pillow_available":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.is_pillow_available","kind":"Gdef"},"is_pydantic_available":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.is_pydantic_available","kind":"Gdef"},"is_pydot_available":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.is_pydot_available","kind":"Gdef"},"is_safetensors_available":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.is_safetensors_available","kind":"Gdef"},"is_simple_optional_type":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._typing.is_simple_optional_type","kind":"Gdef"},"is_tensorboard_available":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.is_tensorboard_available","kind":"Gdef"},"is_tf_available":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.is_tf_available","kind":"Gdef"},"is_torch_available":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.is_torch_available","kind":"Gdef"},"is_tqdm_disabled":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils.tqdm.is_tqdm_disabled","kind":"Gdef"},"list_credential_helpers":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._git_credential.list_credential_helpers","kind":"Gdef"},"paginate":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._pagination.paginate","kind":"Gdef"},"parse_datetime":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._datetime.parse_datetime","kind":"Gdef"},"parse_xet_file_data_from_response":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._xet.parse_xet_file_data_from_response","kind":"Gdef"},"refresh_xet_connection_info":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._xet.refresh_xet_connection_info","kind":"Gdef"},"run_interactive_subprocess":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._subprocess.run_interactive_subprocess","kind":"Gdef"},"run_subprocess":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._subprocess.run_subprocess","kind":"Gdef"},"scan_cache_dir":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._cache_manager.scan_cache_dir","kind":"Gdef"},"send_telemetry":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._telemetry.send_telemetry","kind":"Gdef"},"set_async_client_factory":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._http.set_async_client_factory","kind":"Gdef"},"set_client_factory":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._http.set_client_factory","kind":"Gdef"},"set_git_credential":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._git_credential.set_git_credential","kind":"Gdef"},"tabulate":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._terminal.tabulate","kind":"Gdef"},"tqdm":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils.tqdm.tqdm","kind":"Gdef"},"tqdm_stream_file":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils.tqdm.tqdm_stream_file","kind":"Gdef"},"unset_git_credential":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._git_credential.unset_git_credential","kind":"Gdef"},"unwrap_simple_optional_type":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._typing.unwrap_simple_optional_type","kind":"Gdef"},"validate_hf_hub_args":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._validators.validate_hf_hub_args","kind":"Gdef"},"validate_repo_id":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._validators.validate_repo_id","kind":"Gdef"},"yaml_dump":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._fixes.yaml_dump","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/__init__.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..79911ec27cf6a188bc2cd64e9092dd65d9b79b7a --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[36,37,38,39,48,49,50,51,52,53,54,67,68,69,108,109,110,111,112,113,114,17,1,1,1,1],"dep_prios":[5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,30,30,30],"dependencies":["huggingface_hub.utils.tqdm","huggingface_hub.utils._auth","huggingface_hub.utils._cache_assets","huggingface_hub.utils._cache_manager","huggingface_hub.utils._chunk_utils","huggingface_hub.utils._datetime","huggingface_hub.utils._experimental","huggingface_hub.utils._fixes","huggingface_hub.utils._git_credential","huggingface_hub.utils._headers","huggingface_hub.utils._http","huggingface_hub.utils._pagination","huggingface_hub.utils._paths","huggingface_hub.utils._runtime","huggingface_hub.utils._safetensors","huggingface_hub.utils._subprocess","huggingface_hub.utils._telemetry","huggingface_hub.utils._terminal","huggingface_hub.utils._typing","huggingface_hub.utils._validators","huggingface_hub.utils._xet","huggingface_hub.errors","builtins","_frozen_importlib","abc","typing"],"hash":"b2eedc5601151d015ffbad681d556a4c926eab42","id":"huggingface_hub.utils","ignore_all":true,"interface_hash":"4dddbe95746b27f3c9b5e0c29530377fad354c02","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/__init__.py","plugin_data":null,"size":3846,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_auth.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_auth.data.json new file mode 100644 index 0000000000000000000000000000000000000000..2c2e39cc2481c2089fb316871c320fd6b8343838 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_auth.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.utils._auth","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Lock":{".class":"SymbolTableNode","cross_ref":"threading.Lock","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"Path":{".class":"SymbolTableNode","cross_ref":"pathlib.Path","kind":"Gdef"},"_GOOGLE_COLAB_SECRET":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"huggingface_hub.utils._auth._GOOGLE_COLAB_SECRET","name":"_GOOGLE_COLAB_SECRET","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"_GOOGLE_COLAB_SECRET_LOCK":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._auth._GOOGLE_COLAB_SECRET_LOCK","name":"_GOOGLE_COLAB_SECRET_LOCK","setter_type":null,"type":"_thread.LockType"}},"_IS_GOOGLE_COLAB_CHECKED":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._auth._IS_GOOGLE_COLAB_CHECKED","name":"_IS_GOOGLE_COLAB_CHECKED","setter_type":null,"type":"builtins.bool"}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._auth.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._auth.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._auth.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._auth.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._auth.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._auth.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_clean_token":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["token"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._auth._clean_token","name":"_clean_token","original_first_arg":"token","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["token"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_clean_token","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_get_token_by_name":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["token_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._auth._get_token_by_name","name":"_get_token_by_name","original_first_arg":"token_name","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["token_name"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_token_by_name","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_get_token_from_environment":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._auth._get_token_from_environment","name":"_get_token_from_environment","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_token_from_environment","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_get_token_from_file":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._auth._get_token_from_file","name":"_get_token_from_file","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_token_from_file","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_get_token_from_google_colab":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._auth._get_token_from_google_colab","name":"_get_token_from_google_colab","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_token_from_google_colab","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_save_stored_tokens":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["stored_tokens"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._auth._save_stored_tokens","name":"_save_stored_tokens","original_first_arg":"stored_tokens","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["stored_tokens"],"arg_types":[{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_save_stored_tokens","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_save_token":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["token","token_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._auth._save_token","name":"_save_token","original_first_arg":"token","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["token","token_name"],"arg_types":["builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_save_token","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"configparser":{".class":"SymbolTableNode","cross_ref":"configparser","kind":"Gdef"},"constants":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.constants","kind":"Gdef"},"get_stored_tokens":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._auth.get_stored_tokens","name":"get_stored_tokens","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_stored_tokens","ret_type":{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_token":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._auth.get_token","name":"get_token","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_token","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_colab_enterprise":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.is_colab_enterprise","kind":"Gdef"},"is_google_colab":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.is_google_colab","kind":"Gdef"},"logger":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._auth.logger","name":"logger","setter_type":null,"type":"logging.Logger"}},"logging":{".class":"SymbolTableNode","cross_ref":"logging","kind":"Gdef"},"os":{".class":"SymbolTableNode","cross_ref":"os","kind":"Gdef"},"warnings":{".class":"SymbolTableNode","cross_ref":"warnings","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_auth.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_auth.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_auth.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..3f17175ed12f6085f67f17ea811663aed1423405 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_auth.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[25,24,16,17,18,19,20,21,22,24,1,1,1,1],"dep_prios":[5,10,10,10,10,10,5,5,5,20,5,30,30,30],"dependencies":["huggingface_hub.utils._runtime","huggingface_hub.constants","configparser","logging","os","warnings","pathlib","threading","typing","huggingface_hub","builtins","_frozen_importlib","_thread","abc"],"hash":"8e4f8cb0b7ab21fad973ed0a59341d3d18f9d08b","id":"huggingface_hub.utils._auth","ignore_all":true,"interface_hash":"f4b6033da17c1edda943faeca854dca6329ccc1c","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_auth.py","plugin_data":null,"size":8279,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_cache_assets.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_cache_assets.data.json new file mode 100644 index 0000000000000000000000000000000000000000..96684ce6aff286862d4b37b0f64a233a7ffacfaf --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_cache_assets.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.utils._cache_assets","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","HF_ASSETS_CACHE":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.constants.HF_ASSETS_CACHE","kind":"Gdef"},"Path":{".class":"SymbolTableNode","cross_ref":"pathlib.Path","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._cache_assets.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._cache_assets.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._cache_assets.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._cache_assets.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._cache_assets.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._cache_assets.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"cached_assets_path":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,5],"arg_names":["library_name","namespace","subfolder","assets_dir"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._cache_assets.cached_assets_path","name":"cached_assets_path","original_first_arg":"library_name","type":{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["library_name","namespace","subfolder","assets_dir"],"arg_types":["builtins.str","builtins.str","builtins.str",{".class":"UnionType","items":["builtins.str","pathlib.Path",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cached_assets_path","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_cache_assets.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_cache_assets.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_cache_assets.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..2d714bf4087a6eefcc9b2e235919ce7598422ec2 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_cache_assets.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[18,15,16,1,1,1,1],"dep_prios":[5,5,5,5,30,30,30],"dependencies":["huggingface_hub.constants","pathlib","typing","builtins","_frozen_importlib","abc","os"],"hash":"892f0cd35c6dcdcea24b7061a0518464cc13c9f5","id":"huggingface_hub.utils._cache_assets","ignore_all":true,"interface_hash":"188430821306d570a0f481dedbce74beaff54439","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_cache_assets.py","plugin_data":null,"size":5728,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_cache_manager.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_cache_manager.data.json new file mode 100644 index 0000000000000000000000000000000000000000..7a5641b9d45970285e6ab52f6d98bab3d4673275 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_cache_manager.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.utils._cache_manager","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","CacheNotFound":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.CacheNotFound","kind":"Gdef"},"CachedFileInfo":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.utils._cache_manager.CachedFileInfo","name":"CachedFileInfo","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._cache_manager.CachedFileInfo","has_param_spec_type":false,"metaclass_type":null,"metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":66,"name":"file_name","type":"builtins.str"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":67,"name":"file_path","type":"pathlib.Path"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":68,"name":"blob_path","type":"pathlib.Path"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":69,"name":"size_on_disk","type":"builtins.int"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":71,"name":"blob_last_accessed","type":"builtins.float"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":72,"name":"blob_last_modified","type":"builtins.float"}],"frozen":true},"dataclass_tag":{}},"module_name":"huggingface_hub.utils._cache_manager","mro":["huggingface_hub.utils._cache_manager.CachedFileInfo","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.CachedFileInfo.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"dataclasses.Field"}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0,0,0],"arg_names":["self","file_name","file_path","blob_path","size_on_disk","blob_last_accessed","blob_last_modified"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._cache_manager.CachedFileInfo.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,0],"arg_names":["self","file_name","file_path","blob_path","size_on_disk","blob_last_accessed","blob_last_modified"],"arg_types":["huggingface_hub.utils._cache_manager.CachedFileInfo","builtins.str","pathlib.Path","pathlib.Path","builtins.int","builtins.float","builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of CachedFileInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5],"arg_names":["file_name","file_path","blob_path","size_on_disk","blob_last_accessed","blob_last_modified"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"huggingface_hub.utils._cache_manager.CachedFileInfo.__mypy-replace","name":"__mypy-replace","original_first_arg":"file_name","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5],"arg_names":["file_name","file_path","blob_path","size_on_disk","blob_last_accessed","blob_last_modified"],"arg_types":["builtins.str","pathlib.Path","pathlib.Path","builtins.int","builtins.float","builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of CachedFileInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.CachedFileInfo.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5],"arg_names":["file_name","file_path","blob_path","size_on_disk","blob_last_accessed","blob_last_modified"],"arg_types":["builtins.str","pathlib.Path","pathlib.Path","builtins.int","builtins.float","builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of CachedFileInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"blob_last_accessed":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.CachedFileInfo.blob_last_accessed","name":"blob_last_accessed","setter_type":null,"type":"builtins.float"}},"blob_last_accessed_str":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.utils._cache_manager.CachedFileInfo.blob_last_accessed_str","name":"blob_last_accessed_str","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.utils._cache_manager.CachedFileInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"blob_last_accessed_str of CachedFileInfo","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"huggingface_hub.utils._cache_manager.CachedFileInfo.blob_last_accessed_str","name":"blob_last_accessed_str","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.utils._cache_manager.CachedFileInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"blob_last_accessed_str of CachedFileInfo","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"blob_last_modified":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.CachedFileInfo.blob_last_modified","name":"blob_last_modified","setter_type":null,"type":"builtins.float"}},"blob_last_modified_str":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.utils._cache_manager.CachedFileInfo.blob_last_modified_str","name":"blob_last_modified_str","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.utils._cache_manager.CachedFileInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"blob_last_modified_str of CachedFileInfo","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"huggingface_hub.utils._cache_manager.CachedFileInfo.blob_last_modified_str","name":"blob_last_modified_str","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.utils._cache_manager.CachedFileInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"blob_last_modified_str of CachedFileInfo","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"blob_path":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.CachedFileInfo.blob_path","name":"blob_path","setter_type":null,"type":"pathlib.Path"}},"file_name":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.CachedFileInfo.file_name","name":"file_name","setter_type":null,"type":"builtins.str"}},"file_path":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.CachedFileInfo.file_path","name":"file_path","setter_type":null,"type":"pathlib.Path"}},"size_on_disk":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.CachedFileInfo.size_on_disk","name":"size_on_disk","setter_type":null,"type":"builtins.int"}},"size_on_disk_str":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.utils._cache_manager.CachedFileInfo.size_on_disk_str","name":"size_on_disk_str","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.utils._cache_manager.CachedFileInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"size_on_disk_str of CachedFileInfo","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"huggingface_hub.utils._cache_manager.CachedFileInfo.size_on_disk_str","name":"size_on_disk_str","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.utils._cache_manager.CachedFileInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"size_on_disk_str of CachedFileInfo","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.utils._cache_manager.CachedFileInfo.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.utils._cache_manager.CachedFileInfo","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"CachedRepoInfo":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.utils._cache_manager.CachedRepoInfo","name":"CachedRepoInfo","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._cache_manager.CachedRepoInfo","has_param_spec_type":false,"metaclass_type":null,"metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":208,"name":"repo_id","type":"builtins.str"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":209,"name":"repo_type","type":{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.utils._cache_manager.REPO_TYPE_T"}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":210,"name":"repo_path","type":"pathlib.Path"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":211,"name":"size_on_disk","type":"builtins.int"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":212,"name":"nb_files","type":"builtins.int"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":213,"name":"revisions","type":{".class":"Instance","args":["huggingface_hub.utils._cache_manager.CachedRevisionInfo"],"extra_attrs":null,"type_ref":"builtins.frozenset"}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":215,"name":"last_accessed","type":"builtins.float"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":216,"name":"last_modified","type":"builtins.float"}],"frozen":true},"dataclass_tag":{}},"module_name":"huggingface_hub.utils._cache_manager","mro":["huggingface_hub.utils._cache_manager.CachedRepoInfo","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.CachedRepoInfo.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"dataclasses.Field"}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0,0,0,0,0],"arg_names":["self","repo_id","repo_type","repo_path","size_on_disk","nb_files","revisions","last_accessed","last_modified"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._cache_manager.CachedRepoInfo.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,0,0,0],"arg_names":["self","repo_id","repo_type","repo_path","size_on_disk","nb_files","revisions","last_accessed","last_modified"],"arg_types":["huggingface_hub.utils._cache_manager.CachedRepoInfo","builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.utils._cache_manager.REPO_TYPE_T"},"pathlib.Path","builtins.int","builtins.int",{".class":"Instance","args":["huggingface_hub.utils._cache_manager.CachedRevisionInfo"],"extra_attrs":null,"type_ref":"builtins.frozenset"},"builtins.float","builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of CachedRepoInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5,5,5],"arg_names":["repo_id","repo_type","repo_path","size_on_disk","nb_files","revisions","last_accessed","last_modified"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"huggingface_hub.utils._cache_manager.CachedRepoInfo.__mypy-replace","name":"__mypy-replace","original_first_arg":"repo_id","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5,5],"arg_names":["repo_id","repo_type","repo_path","size_on_disk","nb_files","revisions","last_accessed","last_modified"],"arg_types":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.utils._cache_manager.REPO_TYPE_T"},"pathlib.Path","builtins.int","builtins.int",{".class":"Instance","args":["huggingface_hub.utils._cache_manager.CachedRevisionInfo"],"extra_attrs":null,"type_ref":"builtins.frozenset"},"builtins.float","builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of CachedRepoInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.CachedRepoInfo.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5,5],"arg_names":["repo_id","repo_type","repo_path","size_on_disk","nb_files","revisions","last_accessed","last_modified"],"arg_types":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.utils._cache_manager.REPO_TYPE_T"},"pathlib.Path","builtins.int","builtins.int",{".class":"Instance","args":["huggingface_hub.utils._cache_manager.CachedRevisionInfo"],"extra_attrs":null,"type_ref":"builtins.frozenset"},"builtins.float","builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of CachedRepoInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"cache_id":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.utils._cache_manager.CachedRepoInfo.cache_id","name":"cache_id","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.utils._cache_manager.CachedRepoInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cache_id of CachedRepoInfo","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"huggingface_hub.utils._cache_manager.CachedRepoInfo.cache_id","name":"cache_id","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.utils._cache_manager.CachedRepoInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cache_id of CachedRepoInfo","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"last_accessed":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.CachedRepoInfo.last_accessed","name":"last_accessed","setter_type":null,"type":"builtins.float"}},"last_accessed_str":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.utils._cache_manager.CachedRepoInfo.last_accessed_str","name":"last_accessed_str","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.utils._cache_manager.CachedRepoInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"last_accessed_str of CachedRepoInfo","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"huggingface_hub.utils._cache_manager.CachedRepoInfo.last_accessed_str","name":"last_accessed_str","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.utils._cache_manager.CachedRepoInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"last_accessed_str of CachedRepoInfo","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"last_modified":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.CachedRepoInfo.last_modified","name":"last_modified","setter_type":null,"type":"builtins.float"}},"last_modified_str":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.utils._cache_manager.CachedRepoInfo.last_modified_str","name":"last_modified_str","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.utils._cache_manager.CachedRepoInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"last_modified_str of CachedRepoInfo","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"huggingface_hub.utils._cache_manager.CachedRepoInfo.last_modified_str","name":"last_modified_str","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.utils._cache_manager.CachedRepoInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"last_modified_str of CachedRepoInfo","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"nb_files":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.CachedRepoInfo.nb_files","name":"nb_files","setter_type":null,"type":"builtins.int"}},"refs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.utils._cache_manager.CachedRepoInfo.refs","name":"refs","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.utils._cache_manager.CachedRepoInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"refs of CachedRepoInfo","ret_type":{".class":"Instance","args":["builtins.str","huggingface_hub.utils._cache_manager.CachedRevisionInfo"],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"huggingface_hub.utils._cache_manager.CachedRepoInfo.refs","name":"refs","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.utils._cache_manager.CachedRepoInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"refs of CachedRepoInfo","ret_type":{".class":"Instance","args":["builtins.str","huggingface_hub.utils._cache_manager.CachedRevisionInfo"],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"repo_id":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.CachedRepoInfo.repo_id","name":"repo_id","setter_type":null,"type":"builtins.str"}},"repo_path":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.CachedRepoInfo.repo_path","name":"repo_path","setter_type":null,"type":"pathlib.Path"}},"repo_type":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.CachedRepoInfo.repo_type","name":"repo_type","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.utils._cache_manager.REPO_TYPE_T"}}},"revisions":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.CachedRepoInfo.revisions","name":"revisions","setter_type":null,"type":{".class":"Instance","args":["huggingface_hub.utils._cache_manager.CachedRevisionInfo"],"extra_attrs":null,"type_ref":"builtins.frozenset"}}},"size_on_disk":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.CachedRepoInfo.size_on_disk","name":"size_on_disk","setter_type":null,"type":"builtins.int"}},"size_on_disk_str":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.utils._cache_manager.CachedRepoInfo.size_on_disk_str","name":"size_on_disk_str","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.utils._cache_manager.CachedRepoInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"size_on_disk_str of CachedRepoInfo","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"huggingface_hub.utils._cache_manager.CachedRepoInfo.size_on_disk_str","name":"size_on_disk_str","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.utils._cache_manager.CachedRepoInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"size_on_disk_str of CachedRepoInfo","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.utils._cache_manager.CachedRepoInfo.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.utils._cache_manager.CachedRepoInfo","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"CachedRevisionInfo":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.utils._cache_manager.CachedRevisionInfo","name":"CachedRevisionInfo","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._cache_manager.CachedRevisionInfo","has_param_spec_type":false,"metaclass_type":null,"metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":140,"name":"commit_hash","type":"builtins.str"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":141,"name":"snapshot_path","type":"pathlib.Path"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":142,"name":"size_on_disk","type":"builtins.int"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":143,"name":"files","type":{".class":"Instance","args":["huggingface_hub.utils._cache_manager.CachedFileInfo"],"extra_attrs":null,"type_ref":"builtins.frozenset"}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":144,"name":"refs","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.frozenset"}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":146,"name":"last_modified","type":"builtins.float"}],"frozen":true},"dataclass_tag":{}},"module_name":"huggingface_hub.utils._cache_manager","mro":["huggingface_hub.utils._cache_manager.CachedRevisionInfo","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.CachedRevisionInfo.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"dataclasses.Field"}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0,0,0],"arg_names":["self","commit_hash","snapshot_path","size_on_disk","files","refs","last_modified"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._cache_manager.CachedRevisionInfo.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,0],"arg_names":["self","commit_hash","snapshot_path","size_on_disk","files","refs","last_modified"],"arg_types":["huggingface_hub.utils._cache_manager.CachedRevisionInfo","builtins.str","pathlib.Path","builtins.int",{".class":"Instance","args":["huggingface_hub.utils._cache_manager.CachedFileInfo"],"extra_attrs":null,"type_ref":"builtins.frozenset"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.frozenset"},"builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of CachedRevisionInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5],"arg_names":["commit_hash","snapshot_path","size_on_disk","files","refs","last_modified"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"huggingface_hub.utils._cache_manager.CachedRevisionInfo.__mypy-replace","name":"__mypy-replace","original_first_arg":"commit_hash","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5],"arg_names":["commit_hash","snapshot_path","size_on_disk","files","refs","last_modified"],"arg_types":["builtins.str","pathlib.Path","builtins.int",{".class":"Instance","args":["huggingface_hub.utils._cache_manager.CachedFileInfo"],"extra_attrs":null,"type_ref":"builtins.frozenset"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.frozenset"},"builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of CachedRevisionInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.CachedRevisionInfo.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5],"arg_names":["commit_hash","snapshot_path","size_on_disk","files","refs","last_modified"],"arg_types":["builtins.str","pathlib.Path","builtins.int",{".class":"Instance","args":["huggingface_hub.utils._cache_manager.CachedFileInfo"],"extra_attrs":null,"type_ref":"builtins.frozenset"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.frozenset"},"builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of CachedRevisionInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"commit_hash":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.CachedRevisionInfo.commit_hash","name":"commit_hash","setter_type":null,"type":"builtins.str"}},"files":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.CachedRevisionInfo.files","name":"files","setter_type":null,"type":{".class":"Instance","args":["huggingface_hub.utils._cache_manager.CachedFileInfo"],"extra_attrs":null,"type_ref":"builtins.frozenset"}}},"last_modified":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.CachedRevisionInfo.last_modified","name":"last_modified","setter_type":null,"type":"builtins.float"}},"last_modified_str":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.utils._cache_manager.CachedRevisionInfo.last_modified_str","name":"last_modified_str","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.utils._cache_manager.CachedRevisionInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"last_modified_str of CachedRevisionInfo","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"huggingface_hub.utils._cache_manager.CachedRevisionInfo.last_modified_str","name":"last_modified_str","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.utils._cache_manager.CachedRevisionInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"last_modified_str of CachedRevisionInfo","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"nb_files":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.utils._cache_manager.CachedRevisionInfo.nb_files","name":"nb_files","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.utils._cache_manager.CachedRevisionInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nb_files of CachedRevisionInfo","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"huggingface_hub.utils._cache_manager.CachedRevisionInfo.nb_files","name":"nb_files","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.utils._cache_manager.CachedRevisionInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nb_files of CachedRevisionInfo","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"refs":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.CachedRevisionInfo.refs","name":"refs","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.frozenset"}}},"size_on_disk":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.CachedRevisionInfo.size_on_disk","name":"size_on_disk","setter_type":null,"type":"builtins.int"}},"size_on_disk_str":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.utils._cache_manager.CachedRevisionInfo.size_on_disk_str","name":"size_on_disk_str","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.utils._cache_manager.CachedRevisionInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"size_on_disk_str of CachedRevisionInfo","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"huggingface_hub.utils._cache_manager.CachedRevisionInfo.size_on_disk_str","name":"size_on_disk_str","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.utils._cache_manager.CachedRevisionInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"size_on_disk_str of CachedRevisionInfo","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"snapshot_path":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.CachedRevisionInfo.snapshot_path","name":"snapshot_path","setter_type":null,"type":"pathlib.Path"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.utils._cache_manager.CachedRevisionInfo.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.utils._cache_manager.CachedRevisionInfo","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"CorruptedCacheException":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.CorruptedCacheException","kind":"Gdef"},"DeleteCacheStrategy":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.utils._cache_manager.DeleteCacheStrategy","name":"DeleteCacheStrategy","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._cache_manager.DeleteCacheStrategy","has_param_spec_type":false,"metaclass_type":null,"metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":280,"name":"expected_freed_size","type":"builtins.int"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":281,"name":"blobs","type":{".class":"Instance","args":["pathlib.Path"],"extra_attrs":null,"type_ref":"builtins.frozenset"}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":282,"name":"refs","type":{".class":"Instance","args":["pathlib.Path"],"extra_attrs":null,"type_ref":"builtins.frozenset"}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":283,"name":"repos","type":{".class":"Instance","args":["pathlib.Path"],"extra_attrs":null,"type_ref":"builtins.frozenset"}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":284,"name":"snapshots","type":{".class":"Instance","args":["pathlib.Path"],"extra_attrs":null,"type_ref":"builtins.frozenset"}}],"frozen":true},"dataclass_tag":{}},"module_name":"huggingface_hub.utils._cache_manager","mro":["huggingface_hub.utils._cache_manager.DeleteCacheStrategy","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.DeleteCacheStrategy.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"dataclasses.Field"}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0,0],"arg_names":["self","expected_freed_size","blobs","refs","repos","snapshots"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._cache_manager.DeleteCacheStrategy.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0],"arg_names":["self","expected_freed_size","blobs","refs","repos","snapshots"],"arg_types":["huggingface_hub.utils._cache_manager.DeleteCacheStrategy","builtins.int",{".class":"Instance","args":["pathlib.Path"],"extra_attrs":null,"type_ref":"builtins.frozenset"},{".class":"Instance","args":["pathlib.Path"],"extra_attrs":null,"type_ref":"builtins.frozenset"},{".class":"Instance","args":["pathlib.Path"],"extra_attrs":null,"type_ref":"builtins.frozenset"},{".class":"Instance","args":["pathlib.Path"],"extra_attrs":null,"type_ref":"builtins.frozenset"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of DeleteCacheStrategy","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5],"arg_names":["expected_freed_size","blobs","refs","repos","snapshots"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"huggingface_hub.utils._cache_manager.DeleteCacheStrategy.__mypy-replace","name":"__mypy-replace","original_first_arg":"expected_freed_size","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5],"arg_names":["expected_freed_size","blobs","refs","repos","snapshots"],"arg_types":["builtins.int",{".class":"Instance","args":["pathlib.Path"],"extra_attrs":null,"type_ref":"builtins.frozenset"},{".class":"Instance","args":["pathlib.Path"],"extra_attrs":null,"type_ref":"builtins.frozenset"},{".class":"Instance","args":["pathlib.Path"],"extra_attrs":null,"type_ref":"builtins.frozenset"},{".class":"Instance","args":["pathlib.Path"],"extra_attrs":null,"type_ref":"builtins.frozenset"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of DeleteCacheStrategy","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.DeleteCacheStrategy.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5],"arg_names":["expected_freed_size","blobs","refs","repos","snapshots"],"arg_types":["builtins.int",{".class":"Instance","args":["pathlib.Path"],"extra_attrs":null,"type_ref":"builtins.frozenset"},{".class":"Instance","args":["pathlib.Path"],"extra_attrs":null,"type_ref":"builtins.frozenset"},{".class":"Instance","args":["pathlib.Path"],"extra_attrs":null,"type_ref":"builtins.frozenset"},{".class":"Instance","args":["pathlib.Path"],"extra_attrs":null,"type_ref":"builtins.frozenset"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of DeleteCacheStrategy","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"blobs":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.DeleteCacheStrategy.blobs","name":"blobs","setter_type":null,"type":{".class":"Instance","args":["pathlib.Path"],"extra_attrs":null,"type_ref":"builtins.frozenset"}}},"execute":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.utils._cache_manager.DeleteCacheStrategy.execute","name":"execute","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.utils._cache_manager.DeleteCacheStrategy"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"execute of DeleteCacheStrategy","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"expected_freed_size":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.DeleteCacheStrategy.expected_freed_size","name":"expected_freed_size","setter_type":null,"type":"builtins.int"}},"expected_freed_size_str":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.utils._cache_manager.DeleteCacheStrategy.expected_freed_size_str","name":"expected_freed_size_str","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.utils._cache_manager.DeleteCacheStrategy"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"expected_freed_size_str of DeleteCacheStrategy","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"huggingface_hub.utils._cache_manager.DeleteCacheStrategy.expected_freed_size_str","name":"expected_freed_size_str","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.utils._cache_manager.DeleteCacheStrategy"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"expected_freed_size_str of DeleteCacheStrategy","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"refs":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.DeleteCacheStrategy.refs","name":"refs","setter_type":null,"type":{".class":"Instance","args":["pathlib.Path"],"extra_attrs":null,"type_ref":"builtins.frozenset"}}},"repos":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.DeleteCacheStrategy.repos","name":"repos","setter_type":null,"type":{".class":"Instance","args":["pathlib.Path"],"extra_attrs":null,"type_ref":"builtins.frozenset"}}},"snapshots":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.DeleteCacheStrategy.snapshots","name":"snapshots","setter_type":null,"type":{".class":"Instance","args":["pathlib.Path"],"extra_attrs":null,"type_ref":"builtins.frozenset"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.utils._cache_manager.DeleteCacheStrategy.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.utils._cache_manager.DeleteCacheStrategy","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"FILES_TO_IGNORE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._cache_manager.FILES_TO_IGNORE","name":"FILES_TO_IGNORE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"HFCacheInfo":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.utils._cache_manager.HFCacheInfo","name":"HFCacheInfo","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._cache_manager.HFCacheInfo","has_param_spec_type":false,"metaclass_type":null,"metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":352,"name":"size_on_disk","type":"builtins.int"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":353,"name":"repos","type":{".class":"Instance","args":["huggingface_hub.utils._cache_manager.CachedRepoInfo"],"extra_attrs":null,"type_ref":"builtins.frozenset"}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":354,"name":"warnings","type":{".class":"Instance","args":["huggingface_hub.errors.CorruptedCacheException"],"extra_attrs":null,"type_ref":"builtins.list"}}],"frozen":true},"dataclass_tag":{}},"module_name":"huggingface_hub.utils._cache_manager","mro":["huggingface_hub.utils._cache_manager.HFCacheInfo","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.HFCacheInfo.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"dataclasses.Field"}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","size_on_disk","repos","warnings"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._cache_manager.HFCacheInfo.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","size_on_disk","repos","warnings"],"arg_types":["huggingface_hub.utils._cache_manager.HFCacheInfo","builtins.int",{".class":"Instance","args":["huggingface_hub.utils._cache_manager.CachedRepoInfo"],"extra_attrs":null,"type_ref":"builtins.frozenset"},{".class":"Instance","args":["huggingface_hub.errors.CorruptedCacheException"],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of HFCacheInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5],"arg_names":["size_on_disk","repos","warnings"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"huggingface_hub.utils._cache_manager.HFCacheInfo.__mypy-replace","name":"__mypy-replace","original_first_arg":"size_on_disk","type":{".class":"CallableType","arg_kinds":[5,5,5],"arg_names":["size_on_disk","repos","warnings"],"arg_types":["builtins.int",{".class":"Instance","args":["huggingface_hub.utils._cache_manager.CachedRepoInfo"],"extra_attrs":null,"type_ref":"builtins.frozenset"},{".class":"Instance","args":["huggingface_hub.errors.CorruptedCacheException"],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of HFCacheInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.HFCacheInfo.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5],"arg_names":["size_on_disk","repos","warnings"],"arg_types":["builtins.int",{".class":"Instance","args":["huggingface_hub.utils._cache_manager.CachedRepoInfo"],"extra_attrs":null,"type_ref":"builtins.frozenset"},{".class":"Instance","args":["huggingface_hub.errors.CorruptedCacheException"],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of HFCacheInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"delete_revisions":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2],"arg_names":["self","revisions"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.utils._cache_manager.HFCacheInfo.delete_revisions","name":"delete_revisions","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2],"arg_names":["self","revisions"],"arg_types":["huggingface_hub.utils._cache_manager.HFCacheInfo","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"delete_revisions of HFCacheInfo","ret_type":"huggingface_hub.utils._cache_manager.DeleteCacheStrategy","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"export_as_table":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5],"arg_names":["self","verbosity"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.utils._cache_manager.HFCacheInfo.export_as_table","name":"export_as_table","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5],"arg_names":["self","verbosity"],"arg_types":["huggingface_hub.utils._cache_manager.HFCacheInfo","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"export_as_table of HFCacheInfo","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"repos":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.HFCacheInfo.repos","name":"repos","setter_type":null,"type":{".class":"Instance","args":["huggingface_hub.utils._cache_manager.CachedRepoInfo"],"extra_attrs":null,"type_ref":"builtins.frozenset"}}},"size_on_disk":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.HFCacheInfo.size_on_disk","name":"size_on_disk","setter_type":null,"type":"builtins.int"}},"size_on_disk_str":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.utils._cache_manager.HFCacheInfo.size_on_disk_str","name":"size_on_disk_str","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.utils._cache_manager.HFCacheInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"size_on_disk_str of HFCacheInfo","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"huggingface_hub.utils._cache_manager.HFCacheInfo.size_on_disk_str","name":"size_on_disk_str","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.utils._cache_manager.HFCacheInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"size_on_disk_str of HFCacheInfo","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"warnings":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._cache_manager.HFCacheInfo.warnings","name":"warnings","setter_type":null,"type":{".class":"Instance","args":["huggingface_hub.errors.CorruptedCacheException"],"extra_attrs":null,"type_ref":"builtins.list"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.utils._cache_manager.HFCacheInfo.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.utils._cache_manager.HFCacheInfo","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"HF_HUB_CACHE":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.constants.HF_HUB_CACHE","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"Path":{".class":"SymbolTableNode","cross_ref":"pathlib.Path","kind":"Gdef"},"REPO_TYPE_T":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.utils._cache_manager.REPO_TYPE_T","line":34,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"model"},{".class":"LiteralType","fallback":"builtins.str","value":"dataset"},{".class":"LiteralType","fallback":"builtins.str","value":"space"}],"uses_pep604_syntax":false}}},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._cache_manager.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._cache_manager.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._cache_manager.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._cache_manager.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._cache_manager.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._cache_manager.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_format_size":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["num"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._cache_manager._format_size","name":"_format_size","original_first_arg":"num","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["num"],"arg_types":["builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_format_size","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_scan_cached_repo":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["repo_path"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._cache_manager._scan_cached_repo","name":"_scan_cached_repo","original_first_arg":"repo_path","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["repo_path"],"arg_types":["pathlib.Path"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_scan_cached_repo","ret_type":"huggingface_hub.utils._cache_manager.CachedRepoInfo","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_try_delete_path":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["path","path_type"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._cache_manager._try_delete_path","name":"_try_delete_path","original_first_arg":"path","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["path","path_type"],"arg_types":["pathlib.Path","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_try_delete_path","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"dataclass":{".class":"SymbolTableNode","cross_ref":"dataclasses.dataclass","kind":"Gdef"},"defaultdict":{".class":"SymbolTableNode","cross_ref":"collections.defaultdict","kind":"Gdef"},"format_timesince":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._parsing.format_timesince","kind":"Gdef"},"logger":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._cache_manager.logger","name":"logger","setter_type":null,"type":"logging.Logger"}},"logging":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils.logging","kind":"Gdef"},"os":{".class":"SymbolTableNode","cross_ref":"os","kind":"Gdef"},"scan_cache_dir":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1],"arg_names":["cache_dir"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._cache_manager.scan_cache_dir","name":"scan_cache_dir","original_first_arg":"cache_dir","type":{".class":"CallableType","arg_kinds":[1],"arg_names":["cache_dir"],"arg_types":[{".class":"UnionType","items":["builtins.str","pathlib.Path",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"scan_cache_dir","ret_type":"huggingface_hub.utils._cache_manager.HFCacheInfo","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"shutil":{".class":"SymbolTableNode","cross_ref":"shutil","kind":"Gdef"},"tabulate":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._terminal.tabulate","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_cache_manager.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_cache_manager.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_cache_manager.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..0835cd7e558a141039f682d79e86d98983ad6e90 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_cache_manager.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[27,28,29,24,26,27,17,18,19,20,21,22,1,1,1,1],"dep_prios":[10,5,5,5,5,20,10,10,5,5,5,5,5,30,30,30],"dependencies":["huggingface_hub.utils.logging","huggingface_hub.utils._parsing","huggingface_hub.utils._terminal","huggingface_hub.errors","huggingface_hub.constants","huggingface_hub.utils","os","shutil","collections","dataclasses","pathlib","typing","builtins","_frozen_importlib","abc","logging"],"hash":"0d206e331410707760fc54c198fbcfe6626b96af","id":"huggingface_hub.utils._cache_manager","ignore_all":true,"interface_hash":"17a9b311e41582db86256aa11a6cc3d7bef91865","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_cache_manager.py","plugin_data":null,"size":32991,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_chunk_utils.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_chunk_utils.data.json new file mode 100644 index 0000000000000000000000000000000000000000..6ba36de026f05affcd77cde6ef7a4dd2016413bc --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_chunk_utils.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.utils._chunk_utils","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef"},"T":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.utils._chunk_utils.T","name":"T","upper_bound":"builtins.object","values":[],"variance":0}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._chunk_utils.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._chunk_utils.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._chunk_utils.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._chunk_utils.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._chunk_utils.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._chunk_utils.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"chunk_iterable":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["iterable","chunk_size"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._chunk_utils.chunk_iterable","name":"chunk_iterable","original_first_arg":"iterable","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["iterable","chunk_size"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.utils._chunk_utils.T","id":-1,"name":"T","namespace":"huggingface_hub.utils._chunk_utils.chunk_iterable","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chunk_iterable","ret_type":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.utils._chunk_utils.T","id":-1,"name":"T","namespace":"huggingface_hub.utils._chunk_utils.chunk_iterable","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"extra_attrs":null,"type_ref":"typing.Iterable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.utils._chunk_utils.T","id":-1,"name":"T","namespace":"huggingface_hub.utils._chunk_utils.chunk_iterable","upper_bound":"builtins.object","values":[],"variance":0}]}}},"itertools":{".class":"SymbolTableNode","cross_ref":"itertools","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_chunk_utils.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_chunk_utils.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_chunk_utils.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..9c6b23584b23aa951f331d19614545d642e80fd7 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_chunk_utils.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106714,"dep_lines":[17,18,1,1,1],"dep_prios":[10,5,5,30,30],"dependencies":["itertools","typing","builtins","_frozen_importlib","abc"],"hash":"d027126ff86971b1355326b54a55241271f1f6c5","id":"huggingface_hub.utils._chunk_utils","ignore_all":true,"interface_hash":"6d60f3c9bca2bcf42af26ffec764e7d4894fc9c8","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_chunk_utils.py","plugin_data":null,"size":2109,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_datetime.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_datetime.data.json new file mode 100644 index 0000000000000000000000000000000000000000..6913b58dd1942abeea1f820cee05314eef125590 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_datetime.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.utils._datetime","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._datetime.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._datetime.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._datetime.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._datetime.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._datetime.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._datetime.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"datetime":{".class":"SymbolTableNode","cross_ref":"datetime.datetime","kind":"Gdef"},"parse_datetime":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["date_string"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._datetime.parse_datetime","name":"parse_datetime","original_first_arg":"date_string","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["date_string"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parse_datetime","ret_type":"datetime.datetime","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"timezone":{".class":"SymbolTableNode","cross_ref":"datetime.timezone","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_datetime.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_datetime.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_datetime.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..d6d17d3ae056a1813eb6ce4d272cd55b6e0d2c06 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_datetime.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106714,"dep_lines":[17,1,1,1,1],"dep_prios":[5,5,30,30,30],"dependencies":["datetime","builtins","_frozen_importlib","abc","typing"],"hash":"69d15915185ceb7d4c7979bbef430b4f65b997a7","id":"huggingface_hub.utils._datetime","ignore_all":true,"interface_hash":"76976518c4b117ba5a62433156672418fb955776","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_datetime.py","plugin_data":null,"size":2770,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_deprecation.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_deprecation.data.json new file mode 100644 index 0000000000000000000000000000000000000000..8118ad2bb811aedf70cd8505523fa69cba9d8278 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_deprecation.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.utils._deprecation","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"Parameter":{".class":"SymbolTableNode","cross_ref":"inspect.Parameter","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._deprecation.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._deprecation.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._deprecation.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._deprecation.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._deprecation.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._deprecation.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_deprecate_arguments":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3,5],"arg_names":["version","deprecated_args","custom_message"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._deprecation._deprecate_arguments","name":"_deprecate_arguments","original_first_arg":"version","type":{".class":"CallableType","arg_kinds":[3,3,5],"arg_names":["version","deprecated_args","custom_message"],"arg_types":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_deprecate_arguments","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_deprecate_method":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,5],"arg_names":["version","message"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._deprecation._deprecate_method","name":"_deprecate_method","original_first_arg":"version","type":{".class":"CallableType","arg_kinds":[3,5],"arg_names":["version","message"],"arg_types":["builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_deprecate_method","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_deprecate_positional_args":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3],"arg_names":["version"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._deprecation._deprecate_positional_args","name":"_deprecate_positional_args","original_first_arg":"version","type":{".class":"CallableType","arg_kinds":[3],"arg_names":["version"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_deprecate_positional_args","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"signature":{".class":"SymbolTableNode","cross_ref":"inspect.signature","kind":"Gdef"},"warnings":{".class":"SymbolTableNode","cross_ref":"warnings","kind":"Gdef"},"wraps":{".class":"SymbolTableNode","cross_ref":"functools.wraps","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_deprecation.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_deprecation.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_deprecation.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..e36009fd3444517d6418fcce9bdb53342175cc66 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_deprecation.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[1,2,3,4,1,1,1],"dep_prios":[10,5,5,5,5,30,30],"dependencies":["warnings","functools","inspect","typing","builtins","_frozen_importlib","abc"],"hash":"85d66d5931d56e683a46addba0c701324ba38aa3","id":"huggingface_hub.utils._deprecation","ignore_all":true,"interface_hash":"a0215a13e7aaf43bf5411019e8bad822bc98cb2d","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_deprecation.py","plugin_data":null,"size":4872,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_experimental.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_experimental.data.json new file mode 100644 index 0000000000000000000000000000000000000000..751bd76cf7784a198db42bcc99a0b7f23a1d64d9 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_experimental.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.utils._experimental","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._experimental.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._experimental.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._experimental.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._experimental.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._experimental.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._experimental.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"constants":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.constants","kind":"Gdef"},"experimental":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["fn"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._experimental.experimental","name":"experimental","original_first_arg":"fn","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["fn"],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"experimental","ret_type":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":"__new__ of HFSummaryWriter","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"warnings":{".class":"SymbolTableNode","cross_ref":"warnings","kind":"Gdef"},"wraps":{".class":"SymbolTableNode","cross_ref":"functools.wraps","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_experimental.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_experimental.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_experimental.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..eac2b4404c1cfe8d335bcc4c157821e3296df6e3 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_experimental.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[21,17,18,19,21,1,1,1],"dep_prios":[10,10,5,5,20,5,30,30],"dependencies":["huggingface_hub.constants","warnings","functools","typing","huggingface_hub","builtins","_frozen_importlib","abc"],"hash":"5f795eb1a86bef73e510a7fd511f812fb2beec8c","id":"huggingface_hub.utils._experimental","ignore_all":true,"interface_hash":"0144743b442e359d89ea2713ad5b4ec025a00cc6","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_experimental.py","plugin_data":null,"size":2470,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_fixes.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_fixes.data.json new file mode 100644 index 0000000000000000000000000000000000000000..ab9ab453cf2342eb4ff0f925033d029fb973109e --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_fixes.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.utils._fixes","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","BaseFileLock":{".class":"SymbolTableNode","cross_ref":"filelock._api.BaseFileLock","kind":"Gdef"},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"FileLock":{".class":"SymbolTableNode","cross_ref":"filelock.FileLock","kind":"Gdef"},"Generator":{".class":"SymbolTableNode","cross_ref":"typing.Generator","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"Path":{".class":"SymbolTableNode","cross_ref":"pathlib.Path","kind":"Gdef"},"SoftFileLock":{".class":"SymbolTableNode","cross_ref":"filelock._soft.SoftFileLock","kind":"Gdef"},"SoftTemporaryDirectory":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1,1,1,4],"arg_names":["suffix","prefix","dir","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated"],"fullname":"huggingface_hub.utils._fixes.SoftTemporaryDirectory","name":"SoftTemporaryDirectory","original_first_arg":"suffix","type":{".class":"CallableType","arg_kinds":[1,1,1,4],"arg_names":["suffix","prefix","dir","kwargs"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["pathlib.Path","builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"SoftTemporaryDirectory","ret_type":{".class":"Instance","args":["pathlib.Path",{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Generator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.utils._fixes.SoftTemporaryDirectory","name":"SoftTemporaryDirectory","setter_type":null,"type":{".class":"CallableType","arg_kinds":[1,1,1,4],"arg_names":["suffix","prefix","dir","kwargs"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["pathlib.Path","builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"SoftTemporaryDirectory","ret_type":{".class":"Instance","args":["pathlib.Path",{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"Timeout":{".class":"SymbolTableNode","cross_ref":"filelock._error.Timeout","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"WeakFileLock":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5],"arg_names":["lock_file","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated"],"fullname":"huggingface_hub.utils._fixes.WeakFileLock","name":"WeakFileLock","original_first_arg":"lock_file","type":{".class":"CallableType","arg_kinds":[0,5],"arg_names":["lock_file","timeout"],"arg_types":[{".class":"UnionType","items":["builtins.str","pathlib.Path"],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"WeakFileLock","ret_type":{".class":"Instance","args":["filelock._api.BaseFileLock",{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Generator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.utils._fixes.WeakFileLock","name":"WeakFileLock","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5],"arg_names":["lock_file","timeout"],"arg_types":[{".class":"UnionType","items":["builtins.str","pathlib.Path"],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"WeakFileLock","ret_type":{".class":"Instance","args":["filelock._api.BaseFileLock",{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._fixes.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._fixes.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._fixes.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._fixes.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._fixes.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._fixes.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_set_write_permission_and_retry":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["func","path","excinfo"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._fixes._set_write_permission_and_retry","name":"_set_write_permission_and_retry","original_first_arg":"func","type":null}},"constants":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.constants","kind":"Gdef"},"contextlib":{".class":"SymbolTableNode","cross_ref":"contextlib","kind":"Gdef"},"logger":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._fixes.logger","name":"logger","setter_type":null,"type":"logging.Logger"}},"logging":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils.logging","kind":"Gdef"},"os":{".class":"SymbolTableNode","cross_ref":"os","kind":"Gdef"},"partial":{".class":"SymbolTableNode","cross_ref":"functools.partial","kind":"Gdef"},"shutil":{".class":"SymbolTableNode","cross_ref":"shutil","kind":"Gdef"},"stat":{".class":"SymbolTableNode","cross_ref":"stat","kind":"Gdef"},"tempfile":{".class":"SymbolTableNode","cross_ref":"tempfile","kind":"Gdef"},"time":{".class":"SymbolTableNode","cross_ref":"time","kind":"Gdef"},"yaml":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"huggingface_hub.utils._fixes.yaml","name":"yaml","setter_type":null,"type":{".class":"AnyType","missing_import_name":"huggingface_hub.utils._fixes.yaml","source_any":null,"type_of_any":3}}},"yaml_dump":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"huggingface_hub.utils._fixes.yaml_dump","name":"yaml_dump","setter_type":null,"type":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_fixes.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_fixes.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_fixes.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..19c5a0425ec71c8f30f94ba45f164908c7cc00cd --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_fixes.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[15,14,15,1,2,3,4,5,6,7,8,9,12,14,1,1,1,1,1,11],"dep_prios":[10,10,20,10,10,10,10,10,10,5,5,5,5,20,5,30,30,30,30,10],"dependencies":["huggingface_hub.utils.logging","huggingface_hub.constants","huggingface_hub.utils","contextlib","os","shutil","stat","tempfile","time","functools","pathlib","typing","filelock","huggingface_hub","builtins","_frozen_importlib","abc","filelock._api","logging"],"hash":"8c4ae9289c7363f95934a9c920424306cfc13b88","id":"huggingface_hub.utils._fixes","ignore_all":true,"interface_hash":"66a9441db5bd9182730661663f97283b23a02eed","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_fixes.py","plugin_data":null,"size":3978,"suppressed":["yaml"],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_git_credential.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_git_credential.data.json new file mode 100644 index 0000000000000000000000000000000000000000..869aefeef61e82c83ae19c02892ed9f441805a21 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_git_credential.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.utils._git_credential","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","ENDPOINT":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.constants.ENDPOINT","kind":"Gdef"},"GIT_CREDENTIAL_REGEX":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._git_credential.GIT_CREDENTIAL_REGEX","name":"GIT_CREDENTIAL_REGEX","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._git_credential.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._git_credential.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._git_credential.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._git_credential.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._git_credential.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._git_credential.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_parse_credential_output":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["output"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._git_credential._parse_credential_output","name":"_parse_credential_output","original_first_arg":"output","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["output"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_parse_credential_output","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"list_credential_helpers":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1],"arg_names":["folder"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._git_credential.list_credential_helpers","name":"list_credential_helpers","original_first_arg":"folder","type":{".class":"CallableType","arg_kinds":[1],"arg_names":["folder"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"list_credential_helpers","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef"},"run_interactive_subprocess":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._subprocess.run_interactive_subprocess","kind":"Gdef"},"run_subprocess":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._subprocess.run_subprocess","kind":"Gdef"},"set_git_credential":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["token","username","folder"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._git_credential.set_git_credential","name":"set_git_credential","original_first_arg":"token","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["token","username","folder"],"arg_types":["builtins.str","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"set_git_credential","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"subprocess":{".class":"SymbolTableNode","cross_ref":"subprocess","kind":"Gdef"},"unset_git_credential":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1,1],"arg_names":["username","folder"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._git_credential.unset_git_credential","name":"unset_git_credential","original_first_arg":"username","type":{".class":"CallableType","arg_kinds":[1,1],"arg_names":["username","folder"],"arg_types":["builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unset_git_credential","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_git_credential.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_git_credential.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_git_credential.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..e8c8a8ed3edc80281d9304bcfae52a70ff9be4dd --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_git_credential.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[22,21,17,18,19,1,1,1,1],"dep_prios":[5,5,10,10,5,5,30,30,30],"dependencies":["huggingface_hub.utils._subprocess","huggingface_hub.constants","re","subprocess","typing","builtins","_frozen_importlib","abc","enum"],"hash":"30ace7c6614541e57664a74d5af431eb8199c530","id":"huggingface_hub.utils._git_credential","ignore_all":true,"interface_hash":"0b166012d5d42cb3fb6f3ea61b30d2046525df0c","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_git_credential.py","plugin_data":null,"size":4612,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_headers.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_headers.data.json new file mode 100644 index 0000000000000000000000000000000000000000..bc3591c31b09234806b94d08886dffb51c894743 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_headers.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.utils._headers","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","LocalTokenNotFoundError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.LocalTokenNotFoundError","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._headers.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._headers.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._headers.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._headers.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._headers.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._headers.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_deduplicate_user_agent":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["user_agent"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._headers._deduplicate_user_agent","name":"_deduplicate_user_agent","original_first_arg":"user_agent","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["user_agent"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_deduplicate_user_agent","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_http_user_agent":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5],"arg_names":["library_name","library_version","user_agent"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._headers._http_user_agent","name":"_http_user_agent","original_first_arg":"library_name","type":{".class":"CallableType","arg_kinds":[5,5,5],"arg_names":["library_name","library_version","user_agent"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_http_user_agent","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"build_hf_headers":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5],"arg_names":["token","library_name","library_version","user_agent","headers"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated"],"fullname":"huggingface_hub.utils._headers.build_hf_headers","name":"build_hf_headers","original_first_arg":"token","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5],"arg_names":["token","library_name","library_version","user_agent","headers"],"arg_types":[{".class":"UnionType","items":["builtins.bool","builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"build_hf_headers","ret_type":{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.utils._headers.build_hf_headers","name":"build_hf_headers","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5],"arg_names":["token","library_name","library_version","user_agent","headers"],"arg_types":[{".class":"UnionType","items":["builtins.bool","builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"build_hf_headers","ret_type":{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"constants":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.constants","kind":"Gdef"},"get_hf_hub_version":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.get_hf_hub_version","kind":"Gdef"},"get_python_version":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.get_python_version","kind":"Gdef"},"get_token":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._auth.get_token","kind":"Gdef"},"get_token_to_send":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["token"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._headers.get_token_to_send","name":"get_token_to_send","original_first_arg":"token","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["token"],"arg_types":[{".class":"UnionType","items":["builtins.bool","builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_token_to_send","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_torch_version":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.get_torch_version","kind":"Gdef"},"is_torch_available":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._runtime.is_torch_available","kind":"Gdef"},"validate_hf_hub_args":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._validators.validate_hf_hub_args","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_headers.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_headers.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_headers.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..8f10def8005892a815991100ce6ad31ac9a8151f --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_headers.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[22,23,29,19,21,17,21,1,1,1],"dep_prios":[5,5,5,5,10,5,20,5,30,30],"dependencies":["huggingface_hub.utils._auth","huggingface_hub.utils._runtime","huggingface_hub.utils._validators","huggingface_hub.errors","huggingface_hub.constants","typing","huggingface_hub","builtins","_frozen_importlib","abc"],"hash":"66d04f2406ccdb97cc470ec22d79e3cd1c21f065","id":"huggingface_hub.utils._headers","ignore_all":true,"interface_hash":"8c355d0a62d957879f9259b3a938fb9a76bb5a13","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_headers.py","plugin_data":null,"size":8060,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_http.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_http.data.json new file mode 100644 index 0000000000000000000000000000000000000000..298dce5d597317b35143f86975ee8b139821f1df --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_http.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.utils._http","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","ASYNC_CLIENT_FACTORY_T":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.utils._http.ASYNC_CLIENT_FACTORY_T","line":150,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"httpx._client.AsyncClient","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BadRequestError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.BadRequestError","kind":"Gdef"},"CLIENT_FACTORY_T":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.utils._http.CLIENT_FACTORY_T","line":149,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"httpx._client.Client","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"DisabledRepoError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.DisabledRepoError","kind":"Gdef"},"GatedRepoError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.GatedRepoError","kind":"Gdef"},"Generator":{".class":"SymbolTableNode","cross_ref":"typing.Generator","kind":"Gdef"},"HTTPStatus":{".class":"SymbolTableNode","cross_ref":"http.HTTPStatus","kind":"Gdef"},"HTTP_METHOD_T":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._typing.HTTP_METHOD_T","kind":"Gdef"},"HfHubHTTPError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.HfHubHTTPError","kind":"Gdef"},"OfflineModeIsEnabled":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.OfflineModeIsEnabled","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"RANGE_REGEX":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._http.RANGE_REGEX","name":"RANGE_REGEX","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"REPO_API_REGEX":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._http.REPO_API_REGEX","name":"REPO_API_REGEX","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"RemoteEntryNotFoundError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.RemoteEntryNotFoundError","kind":"Gdef"},"RepositoryNotFoundError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.RepositoryNotFoundError","kind":"Gdef"},"RevisionNotFoundError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.RevisionNotFoundError","kind":"Gdef"},"SliceFileObj":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._lfs.SliceFileObj","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"X_AMZN_TRACE_ID":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._http.X_AMZN_TRACE_ID","name":"X_AMZN_TRACE_ID","setter_type":null,"type":"builtins.str"}},"X_REQUEST_ID":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._http.X_REQUEST_ID","name":"X_REQUEST_ID","setter_type":null,"type":"builtins.str"}},"_CLIENT_LOCK":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._http._CLIENT_LOCK","name":"_CLIENT_LOCK","setter_type":null,"type":"_thread.LockType"}},"_GLOBAL_ASYNC_CLIENT_FACTORY":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"huggingface_hub.utils._http._GLOBAL_ASYNC_CLIENT_FACTORY","name":"_GLOBAL_ASYNC_CLIENT_FACTORY","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.utils._http.ASYNC_CLIENT_FACTORY_T"}}},"_GLOBAL_CLIENT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"huggingface_hub.utils._http._GLOBAL_CLIENT","name":"_GLOBAL_CLIENT","setter_type":null,"type":{".class":"UnionType","items":["httpx._client.Client",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"_GLOBAL_CLIENT_FACTORY":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"huggingface_hub.utils._http._GLOBAL_CLIENT_FACTORY","name":"_GLOBAL_CLIENT_FACTORY","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.utils._http.CLIENT_FACTORY_T"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._http.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._http.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._http.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._http.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._http.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._http.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_adjust_range_header":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["original_range","resume_size"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._http._adjust_range_header","name":"_adjust_range_header","original_first_arg":"original_range","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["original_range","resume_size"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_adjust_range_header","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_curlify":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["request"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._http._curlify","name":"_curlify","original_first_arg":"request","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["request"],"arg_types":["httpx._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_curlify","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_format":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["error_type","custom_message","response"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._http._format","name":"_format","original_first_arg":"error_type","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["error_type","custom_message","response"],"arg_types":[{".class":"TypeType","item":"huggingface_hub.errors.HfHubHTTPError"},"builtins.str","httpx._models.Response"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_format","ret_type":"huggingface_hub.errors.HfHubHTTPError","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_http_backoff_base":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5,5,4],"arg_names":["method","url","max_retries","base_wait_time","max_wait_time","retry_on_exceptions","retry_on_status_codes","stream","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._http._http_backoff_base","name":"_http_backoff_base","original_first_arg":"method","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,4],"arg_names":["method","url","max_retries","base_wait_time","max_wait_time","retry_on_exceptions","retry_on_status_codes","stream","kwargs"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.utils._typing.HTTP_METHOD_T"},"builtins.str","builtins.int","builtins.float","builtins.float",{".class":"UnionType","items":[{".class":"TypeType","item":"builtins.Exception"},{".class":"Instance","args":[{".class":"TypeType","item":"builtins.Exception"}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":false},"builtins.bool",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_http_backoff_base","ret_type":{".class":"Instance","args":["httpx._models.Response",{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Generator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"async_hf_request_event_hook":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["request"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine"],"fullname":"huggingface_hub.utils._http.async_hf_request_event_hook","name":"async_hf_request_event_hook","original_first_arg":"request","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["request"],"arg_types":["httpx._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"async_hf_request_event_hook","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"async_hf_response_event_hook":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["response"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine"],"fullname":"huggingface_hub.utils._http.async_hf_response_event_hook","name":"async_hf_response_event_hook","original_first_arg":"response","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["response"],"arg_types":["httpx._models.Response"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"async_hf_response_event_hook","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"atexit":{".class":"SymbolTableNode","cross_ref":"atexit","kind":"Gdef"},"close_session":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._http.close_session","name":"close_session","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"close_session","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"constants":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.constants","kind":"Gdef"},"contextmanager":{".class":"SymbolTableNode","cross_ref":"contextlib.contextmanager","kind":"Gdef"},"default_async_client_factory":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._http.default_async_client_factory","name":"default_async_client_factory","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"default_async_client_factory","ret_type":"httpx._client.AsyncClient","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"default_client_factory":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._http.default_client_factory","name":"default_client_factory","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"default_client_factory","ret_type":"httpx._client.Client","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"fix_hf_endpoint_in_url":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["url","endpoint"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._http.fix_hf_endpoint_in_url","name":"fix_hf_endpoint_in_url","original_first_arg":"url","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["url","endpoint"],"arg_types":["builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fix_hf_endpoint_in_url","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_async_session":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._http.get_async_session","name":"get_async_session","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_async_session","ret_type":"httpx._client.AsyncClient","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_session":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._http.get_session","name":"get_session","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_session","ret_type":"httpx._client.Client","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"hf_raise_for_status":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["response","endpoint_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._http.hf_raise_for_status","name":"hf_raise_for_status","original_first_arg":"response","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["response","endpoint_name"],"arg_types":["httpx._models.Response",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hf_raise_for_status","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"hf_request_event_hook":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["request"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._http.hf_request_event_hook","name":"hf_request_event_hook","original_first_arg":"request","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["request"],"arg_types":["httpx._models.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hf_request_event_hook","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"http_backoff":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5,4],"arg_names":["method","url","max_retries","base_wait_time","max_wait_time","retry_on_exceptions","retry_on_status_codes","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._http.http_backoff","name":"http_backoff","original_first_arg":"method","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,4],"arg_names":["method","url","max_retries","base_wait_time","max_wait_time","retry_on_exceptions","retry_on_status_codes","kwargs"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.utils._typing.HTTP_METHOD_T"},"builtins.str","builtins.int","builtins.float","builtins.float",{".class":"UnionType","items":[{".class":"TypeType","item":"builtins.Exception"},{".class":"Instance","args":[{".class":"TypeType","item":"builtins.Exception"}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"http_backoff","ret_type":"httpx._models.Response","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"http_stream_backoff":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5,4],"arg_names":["method","url","max_retries","base_wait_time","max_wait_time","retry_on_exceptions","retry_on_status_codes","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated"],"fullname":"huggingface_hub.utils._http.http_stream_backoff","name":"http_stream_backoff","original_first_arg":"method","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,4],"arg_names":["method","url","max_retries","base_wait_time","max_wait_time","retry_on_exceptions","retry_on_status_codes","kwargs"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.utils._typing.HTTP_METHOD_T"},"builtins.str","builtins.int","builtins.float","builtins.float",{".class":"UnionType","items":[{".class":"TypeType","item":"builtins.Exception"},{".class":"Instance","args":[{".class":"TypeType","item":"builtins.Exception"}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"http_stream_backoff","ret_type":{".class":"Instance","args":["httpx._models.Response",{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Generator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.utils._http.http_stream_backoff","name":"http_stream_backoff","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,4],"arg_names":["method","url","max_retries","base_wait_time","max_wait_time","retry_on_exceptions","retry_on_status_codes","kwargs"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.utils._typing.HTTP_METHOD_T"},"builtins.str","builtins.int","builtins.float","builtins.float",{".class":"UnionType","items":[{".class":"TypeType","item":"builtins.Exception"},{".class":"Instance","args":[{".class":"TypeType","item":"builtins.Exception"}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"http_stream_backoff","ret_type":{".class":"Instance","args":["httpx._models.Response",{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"httpx":{".class":"SymbolTableNode","cross_ref":"httpx","kind":"Gdef"},"io":{".class":"SymbolTableNode","cross_ref":"io","kind":"Gdef"},"json":{".class":"SymbolTableNode","cross_ref":"json","kind":"Gdef"},"logger":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._http.logger","name":"logger","setter_type":null,"type":"logging.Logger"}},"logging":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils.logging","kind":"Gdef"},"os":{".class":"SymbolTableNode","cross_ref":"os","kind":"Gdef"},"quote":{".class":"SymbolTableNode","cross_ref":"shlex.quote","kind":"Gdef"},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef"},"set_async_client_factory":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["async_client_factory"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._http.set_async_client_factory","name":"set_async_client_factory","original_first_arg":"async_client_factory","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["async_client_factory"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.utils._http.ASYNC_CLIENT_FACTORY_T"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"set_async_client_factory","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"set_client_factory":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["client_factory"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._http.set_client_factory","name":"set_client_factory","original_first_arg":"client_factory","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["client_factory"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.utils._http.CLIENT_FACTORY_T"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"set_client_factory","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"threading":{".class":"SymbolTableNode","cross_ref":"threading","kind":"Gdef"},"time":{".class":"SymbolTableNode","cross_ref":"time","kind":"Gdef"},"uuid":{".class":"SymbolTableNode","cross_ref":"uuid","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_http.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_http.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_http.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..455c45efbd111008a35240f9ec28adc1247aa089 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_http.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[44,45,46,32,34,44,17,18,19,20,21,22,23,24,25,26,27,28,30,34,1,1,1,1,1,1,1,1,1,1],"dep_prios":[10,5,5,5,10,20,10,10,10,10,10,10,10,10,5,5,5,5,10,20,5,30,30,30,30,30,30,30,30,30],"dependencies":["huggingface_hub.utils.logging","huggingface_hub.utils._lfs","huggingface_hub.utils._typing","huggingface_hub.errors","huggingface_hub.constants","huggingface_hub.utils","atexit","io","json","os","re","threading","time","uuid","contextlib","http","shlex","typing","httpx","huggingface_hub","builtins","_frozen_importlib","_thread","abc","enum","httpx._client","httpx._exceptions","httpx._models","logging","types"],"hash":"9edb1339b3275404d6871886d09b3ae2ef357b5e","id":"huggingface_hub.utils._http","ignore_all":true,"interface_hash":"34c40d388c0df2442996e5da158f3c62bbe5bcf7","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_http.py","plugin_data":null,"size":31524,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_lfs.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_lfs.data.json new file mode 100644 index 0000000000000000000000000000000000000000..42f577781cc32a6aaf4ea7d7aee3ad851e0ba0da --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_lfs.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.utils._lfs","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","AbstractContextManager":{".class":"SymbolTableNode","cross_ref":"contextlib.AbstractContextManager","kind":"Gdef"},"BinaryIO":{".class":"SymbolTableNode","cross_ref":"typing.BinaryIO","kind":"Gdef"},"SliceFileObj":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"contextlib.AbstractContextManager"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.utils._lfs.SliceFileObj","name":"SliceFileObj","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._lfs.SliceFileObj","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"huggingface_hub.utils._lfs","mro":["huggingface_hub.utils._lfs.SliceFileObj","contextlib.AbstractContextManager","abc.ABC","builtins.object"],"names":{".class":"SymbolTable","__enter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._lfs.SliceFileObj.__enter__","name":"__enter__","original_first_arg":"self","type":null}},"__exit__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":[null,null,null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._lfs.SliceFileObj.__exit__","name":"__exit__","original_first_arg":"self","type":null}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","fileobj","seek_from","read_limit"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.utils._lfs.SliceFileObj.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","fileobj","seek_from","read_limit"],"arg_types":["huggingface_hub.utils._lfs.SliceFileObj","typing.BinaryIO","builtins.int","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of SliceFileObj","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__iter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._lfs.SliceFileObj.__iter__","name":"__iter__","original_first_arg":"self","type":null}},"_len":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.utils._lfs.SliceFileObj._len","name":"_len","setter_type":null,"type":"builtins.int"}},"_previous_position":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.utils._lfs.SliceFileObj._previous_position","name":"_previous_position","setter_type":null,"type":"builtins.int"}},"fileobj":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.utils._lfs.SliceFileObj.fileobj","name":"fileobj","setter_type":null,"type":"typing.BinaryIO"}},"read":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","n"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.utils._lfs.SliceFileObj.read","name":"read","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","n"],"arg_types":["huggingface_hub.utils._lfs.SliceFileObj","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"read of SliceFileObj","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"read_limit":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.utils._lfs.SliceFileObj.read_limit","name":"read_limit","setter_type":null,"type":"builtins.int"}},"seek":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","offset","whence"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.utils._lfs.SliceFileObj.seek","name":"seek","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","offset","whence"],"arg_types":["huggingface_hub.utils._lfs.SliceFileObj","builtins.int","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"seek of SliceFileObj","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"seek_from":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.utils._lfs.SliceFileObj.seek_from","name":"seek_from","setter_type":null,"type":"builtins.int"}},"tell":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.utils._lfs.SliceFileObj.tell","name":"tell","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.utils._lfs.SliceFileObj"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tell of SliceFileObj","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.utils._lfs.SliceFileObj.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.utils._lfs.SliceFileObj","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._lfs.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._lfs.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._lfs.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._lfs.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._lfs.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._lfs.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"io":{".class":"SymbolTableNode","cross_ref":"io","kind":"Gdef"},"os":{".class":"SymbolTableNode","cross_ref":"os","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_lfs.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_lfs.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_lfs.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..d38e7c15487bbc03c5d0377c7feb3ff186e53780 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_lfs.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106713,"dep_lines":[17,18,19,20,1,1,1,1],"dep_prios":[10,10,5,5,5,30,30,30],"dependencies":["io","os","contextlib","typing","builtins","_frozen_importlib","_typeshed","abc"],"hash":"129e4853a97db681b82aea0b8eb234e1629b2540","id":"huggingface_hub.utils._lfs","ignore_all":true,"interface_hash":"ea02af3bf9fe93a811b83e4ff1324775aec228e9","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_lfs.py","plugin_data":null,"size":3957,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_pagination.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_pagination.data.json new file mode 100644 index 0000000000000000000000000000000000000000..d2f1637f289e0ead3b020e1e29087697692fde42 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_pagination.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.utils._pagination","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._pagination.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._pagination.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._pagination.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._pagination.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._pagination.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._pagination.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_get_next_page":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["response"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._pagination._get_next_page","name":"_get_next_page","original_first_arg":"response","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["response"],"arg_types":["httpx._models.Response"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_next_page","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_session":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._http.get_session","kind":"Gdef"},"hf_raise_for_status":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._http.hf_raise_for_status","kind":"Gdef"},"http_backoff":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._http.http_backoff","kind":"Gdef"},"httpx":{".class":"SymbolTableNode","cross_ref":"httpx","kind":"Gdef"},"logger":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._pagination.logger","name":"logger","setter_type":null,"type":"logging.Logger"}},"logging":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils.logging","kind":"Gdef"},"paginate":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["path","params","headers"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._pagination.paginate","name":"paginate","original_first_arg":"path","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["path","params","headers"],"arg_types":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"paginate","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"typing.Iterable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_pagination.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_pagination.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_pagination.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..c987cef921b530c3519082869d96bcb61c51bfe9 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_pagination.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[21,21,17,19,1,1,1,1,1],"dep_prios":[10,5,5,10,5,30,30,30,30],"dependencies":["huggingface_hub.utils.logging","huggingface_hub.utils","typing","httpx","builtins","_frozen_importlib","abc","httpx._models","logging"],"hash":"efd97a00f6bfbe3b1ffa59648b71101f7ddec5eb","id":"huggingface_hub.utils._pagination","ignore_all":true,"interface_hash":"707b905f46b0dcc7b62e3542cd2bbfa0b727aecf","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_pagination.py","plugin_data":null,"size":1894,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_parsing.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_parsing.data.json new file mode 100644 index 0000000000000000000000000000000000000000..601c6c45bdf14a5a71bba40f23f6e4efd81469e1 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_parsing.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.utils._parsing","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","BYTE_UNITS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"huggingface_hub.utils._parsing.BYTE_UNITS","name":"BYTE_UNITS","setter_type":null,"type":{".class":"Instance","args":["builtins.str","builtins.int"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"Dict":{".class":"SymbolTableNode","cross_ref":"typing.Dict","kind":"Gdef"},"RE_NUMBER_WITH_UNIT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._parsing.RE_NUMBER_WITH_UNIT","name":"RE_NUMBER_WITH_UNIT","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"TIME_UNITS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"huggingface_hub.utils._parsing.TIME_UNITS","name":"TIME_UNITS","setter_type":null,"type":{".class":"Instance","args":["builtins.str","builtins.int"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._parsing.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._parsing.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._parsing.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._parsing.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._parsing.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._parsing.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_parse_with_unit":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["value","units"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._parsing._parse_with_unit","name":"_parse_with_unit","original_first_arg":"value","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["value","units"],"arg_types":["builtins.str",{".class":"Instance","args":["builtins.str","builtins.int"],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_parse_with_unit","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"format_timesince":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["ts"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._parsing.format_timesince","name":"format_timesince","original_first_arg":"ts","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["ts"],"arg_types":["builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"format_timesince","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"parse_duration":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["value"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._parsing.parse_duration","name":"parse_duration","original_first_arg":"value","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["value"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parse_duration","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"parse_size":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["value"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._parsing.parse_size","name":"parse_size","original_first_arg":"value","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["value"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parse_size","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef"},"time":{".class":"SymbolTableNode","cross_ref":"time","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_parsing.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_parsing.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_parsing.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..6afd75c444bb24c780971367f01b0fc6f1373e01 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_parsing.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106714,"dep_lines":[17,18,19,1,1,1,1],"dep_prios":[10,10,5,5,30,30,30],"dependencies":["re","time","typing","builtins","_frozen_importlib","abc","enum"],"hash":"313a5d7f5e01c071a499bb2dcff5cfb27506614d","id":"huggingface_hub.utils._parsing","ignore_all":true,"interface_hash":"64b52e32649557a0e985b043c7a7bfc274c8cf16","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_parsing.py","plugin_data":null,"size":3021,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_paths.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_paths.data.json new file mode 100644 index 0000000000000000000000000000000000000000..520f583098df0569c863ef5de219c46900e95758 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_paths.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.utils._paths","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"DEFAULT_IGNORE_PATTERNS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._paths.DEFAULT_IGNORE_PATTERNS","name":"DEFAULT_IGNORE_PATTERNS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"FORBIDDEN_FOLDERS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._paths.FORBIDDEN_FOLDERS","name":"FORBIDDEN_FOLDERS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"Generator":{".class":"SymbolTableNode","cross_ref":"typing.Generator","kind":"Gdef"},"Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"Path":{".class":"SymbolTableNode","cross_ref":"pathlib.Path","kind":"Gdef"},"T":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.utils._paths.T","name":"T","upper_bound":"builtins.object","values":[],"variance":0}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._paths.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._paths.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._paths.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._paths.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._paths.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._paths.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_add_wildcard_to_directories":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["pattern"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._paths._add_wildcard_to_directories","name":"_add_wildcard_to_directories","original_first_arg":"pattern","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["pattern"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_add_wildcard_to_directories","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"filter_repo_objects":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5],"arg_names":["items","allow_patterns","ignore_patterns","key"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._paths.filter_repo_objects","name":"filter_repo_objects","original_first_arg":"items","type":{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":["items","allow_patterns","ignore_patterns","key"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.utils._paths.T","id":-1,"name":"T","namespace":"huggingface_hub.utils._paths.filter_repo_objects","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},"builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},"builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.utils._paths.T","id":-1,"name":"T","namespace":"huggingface_hub.utils._paths.filter_repo_objects","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"filter_repo_objects","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.utils._paths.T","id":-1,"name":"T","namespace":"huggingface_hub.utils._paths.filter_repo_objects","upper_bound":"builtins.object","values":[],"variance":0},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Generator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.utils._paths.T","id":-1,"name":"T","namespace":"huggingface_hub.utils._paths.filter_repo_objects","upper_bound":"builtins.object","values":[],"variance":0}]}}},"fnmatch":{".class":"SymbolTableNode","cross_ref":"fnmatch.fnmatch","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_paths.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_paths.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_paths.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..e9166d6b9636d089d66b3109b82c2ddf308702ac --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_paths.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106714,"dep_lines":[17,18,19,1,1,1],"dep_prios":[5,5,5,5,30,30],"dependencies":["fnmatch","pathlib","typing","builtins","_frozen_importlib","abc"],"hash":"01f640beaa0597d71d793974d6ee492cdd826be4","id":"huggingface_hub.utils._paths","ignore_all":true,"interface_hash":"b7eafd72bc0cbbdb940028eb820373298c818fab","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_paths.py","plugin_data":null,"size":5036,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_runtime.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_runtime.data.json new file mode 100644 index 0000000000000000000000000000000000000000..94390b457f0e512859bdb8aaee2df57b1e851f6a --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_runtime.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.utils._runtime","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"Path":{".class":"SymbolTableNode","cross_ref":"pathlib.Path","kind":"Gdef"},"_CANDIDATES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._runtime._CANDIDATES","name":"_CANDIDATES","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Collection"}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_PY_VERSION":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"huggingface_hub.utils._runtime._PY_VERSION","name":"_PY_VERSION","setter_type":null,"type":"builtins.str"}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._runtime.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._runtime.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._runtime.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._runtime.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._runtime.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._runtime.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"__version__":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.__version__","kind":"Gdef"},"_get_version":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["package_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime._get_version","name":"_get_version","original_first_arg":"package_name","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["package_name"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_version","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_is_brew_installation":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime._is_brew_installation","name":"_is_brew_installation","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_is_brew_installation","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_is_google_colab":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._runtime._is_google_colab","name":"_is_google_colab","setter_type":null,"type":"builtins.bool"}},"_is_hf_installer_installation":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime._is_hf_installer_installation","name":"_is_hf_installer_installation","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_is_hf_installer_installation","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_package_versions":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._runtime._package_versions","name":"_package_versions","setter_type":null,"type":{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"candidate_name":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._runtime.candidate_name","name":"candidate_name","setter_type":null,"type":"builtins.str"}},"constants":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.constants","kind":"Gdef"},"dump_environment_info":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.dump_environment_info","name":"dump_environment_info","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dump_environment_info","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_aiohttp_version":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.get_aiohttp_version","name":"get_aiohttp_version","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_aiohttp_version","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_fastai_version":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.get_fastai_version","name":"get_fastai_version","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_fastai_version","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_fastapi_version":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.get_fastapi_version","name":"get_fastapi_version","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_fastapi_version","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_fastcore_version":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.get_fastcore_version","name":"get_fastcore_version","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_fastcore_version","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_gradio_version":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.get_gradio_version","name":"get_gradio_version","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_gradio_version","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_graphviz_version":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.get_graphviz_version","name":"get_graphviz_version","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_graphviz_version","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_hf_hub_version":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.get_hf_hub_version","name":"get_hf_hub_version","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_hf_hub_version","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_httpx_version":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.get_httpx_version","name":"get_httpx_version","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_httpx_version","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_jinja_version":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.get_jinja_version","name":"get_jinja_version","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_jinja_version","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_keras_version":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.get_keras_version","name":"get_keras_version","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_keras_version","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_numpy_version":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.get_numpy_version","name":"get_numpy_version","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_numpy_version","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_pillow_version":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.get_pillow_version","name":"get_pillow_version","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_pillow_version","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_pydantic_version":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.get_pydantic_version","name":"get_pydantic_version","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_pydantic_version","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_pydot_version":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.get_pydot_version","name":"get_pydot_version","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_pydot_version","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_python_version":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.get_python_version","name":"get_python_version","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_python_version","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_tensorboard_version":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.get_tensorboard_version","name":"get_tensorboard_version","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_tensorboard_version","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_tf_version":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.get_tf_version","name":"get_tf_version","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_tf_version","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_torch_version":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.get_torch_version","name":"get_torch_version","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_torch_version","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_xet_version":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.get_xet_version","name":"get_xet_version","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_xet_version","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"importlib":{".class":"SymbolTableNode","cross_ref":"importlib","kind":"Gdef"},"installation_method":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.installation_method","name":"installation_method","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"installation_method","ret_type":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"brew"},{".class":"LiteralType","fallback":"builtins.str","value":"hf_installer"},{".class":"LiteralType","fallback":"builtins.str","value":"unknown"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_aiohttp_available":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.is_aiohttp_available","name":"is_aiohttp_available","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_aiohttp_available","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_colab_enterprise":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.is_colab_enterprise","name":"is_colab_enterprise","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_colab_enterprise","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_fastai_available":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.is_fastai_available","name":"is_fastai_available","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_fastai_available","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_fastapi_available":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.is_fastapi_available","name":"is_fastapi_available","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_fastapi_available","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_fastcore_available":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.is_fastcore_available","name":"is_fastcore_available","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_fastcore_available","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_google_colab":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.is_google_colab","name":"is_google_colab","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_google_colab","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_gradio_available":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.is_gradio_available","name":"is_gradio_available","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_gradio_available","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_graphviz_available":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.is_graphviz_available","name":"is_graphviz_available","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_graphviz_available","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_httpx_available":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.is_httpx_available","name":"is_httpx_available","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_httpx_available","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_jinja_available":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.is_jinja_available","name":"is_jinja_available","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_jinja_available","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_keras_available":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.is_keras_available","name":"is_keras_available","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_keras_available","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_notebook":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.is_notebook","name":"is_notebook","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_notebook","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_numpy_available":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.is_numpy_available","name":"is_numpy_available","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_numpy_available","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_package_available":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["package_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.is_package_available","name":"is_package_available","original_first_arg":"package_name","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["package_name"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_package_available","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_pillow_available":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.is_pillow_available","name":"is_pillow_available","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_pillow_available","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_pydantic_available":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.is_pydantic_available","name":"is_pydantic_available","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_pydantic_available","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_pydot_available":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.is_pydot_available","name":"is_pydot_available","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_pydot_available","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_safetensors_available":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.is_safetensors_available","name":"is_safetensors_available","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_safetensors_available","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_tensorboard_available":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.is_tensorboard_available","name":"is_tensorboard_available","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_tensorboard_available","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_tf_available":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.is_tf_available","name":"is_tf_available","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_tf_available","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_torch_available":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.is_torch_available","name":"is_torch_available","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_torch_available","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_xet_available":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._runtime.is_xet_available","name":"is_xet_available","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_xet_available","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"name":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_index_var","is_ready","is_inferred"],"fullname":"huggingface_hub.utils._runtime.name","name":"name","setter_type":null,"type":"builtins.str"}},"os":{".class":"SymbolTableNode","cross_ref":"os","kind":"Gdef"},"package_names":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._runtime.package_names","name":"package_names","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Collection"}}},"platform":{".class":"SymbolTableNode","cross_ref":"platform","kind":"Gdef"},"sys":{".class":"SymbolTableNode","cross_ref":"sys","kind":"Gdef"},"warnings":{".class":"SymbolTableNode","cross_ref":"warnings","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_runtime.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_runtime.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_runtime.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..d37cd54ea26175173ea1269ede6cc73f85bfdce2 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_runtime.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[17,25,17,18,19,20,21,22,23,25,1,1,1,1,1],"dep_prios":[10,10,20,10,10,10,10,5,5,5,5,30,30,30,30],"dependencies":["importlib.metadata","huggingface_hub.constants","importlib","os","platform","sys","warnings","pathlib","typing","huggingface_hub","builtins","_collections_abc","_frozen_importlib","abc","typing_extensions"],"hash":"4892f8391391c48b7f56ae5deee74d864f7e061e","id":"huggingface_hub.utils._runtime","ignore_all":true,"interface_hash":"cdc6956a9aec63eb0da7fec3a78e1ff9b0fc7e1c","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_runtime.py","plugin_data":null,"size":12595,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_safetensors.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_safetensors.data.json new file mode 100644 index 0000000000000000000000000000000000000000..66aea7690382ef6a7b2424fa14741a7d694fdc6e --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_safetensors.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.utils._safetensors","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","DTYPE_T":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.utils._safetensors.DTYPE_T","line":10,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"F64"},{".class":"LiteralType","fallback":"builtins.str","value":"F32"},{".class":"LiteralType","fallback":"builtins.str","value":"F16"},{".class":"LiteralType","fallback":"builtins.str","value":"BF16"},{".class":"LiteralType","fallback":"builtins.str","value":"I64"},{".class":"LiteralType","fallback":"builtins.str","value":"I32"},{".class":"LiteralType","fallback":"builtins.str","value":"I16"},{".class":"LiteralType","fallback":"builtins.str","value":"I8"},{".class":"LiteralType","fallback":"builtins.str","value":"U8"},{".class":"LiteralType","fallback":"builtins.str","value":"BOOL"}],"uses_pep604_syntax":false}}},"FILENAME_T":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.utils._safetensors.FILENAME_T","line":8,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":"builtins.str"}},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"SafetensorsFileMetadata":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.utils._safetensors.SafetensorsFileMetadata","name":"SafetensorsFileMetadata","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._safetensors.SafetensorsFileMetadata","has_param_spec_type":false,"metaclass_type":null,"metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":62,"name":"metadata","type":{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":63,"name":"tensors","type":{".class":"Instance","args":["builtins.str","huggingface_hub.utils._safetensors.TensorInfo"],"extra_attrs":null,"type_ref":"builtins.dict"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":64,"name":"parameter_count","type":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.utils._safetensors.DTYPE_T"},"builtins.int"],"extra_attrs":null,"type_ref":"builtins.dict"}}],"frozen":false},"dataclass_tag":{}},"module_name":"huggingface_hub.utils._safetensors","mro":["huggingface_hub.utils._safetensors.SafetensorsFileMetadata","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"huggingface_hub.utils._safetensors.SafetensorsFileMetadata.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"dataclasses.Field"}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","metadata","tensors"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._safetensors.SafetensorsFileMetadata.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","metadata","tensors"],"arg_types":["huggingface_hub.utils._safetensors.SafetensorsFileMetadata",{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str","huggingface_hub.utils._safetensors.TensorInfo"],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of SafetensorsFileMetadata","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-post_init":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._safetensors.SafetensorsFileMetadata.__mypy-post_init","name":"__mypy-post_init","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.utils._safetensors.SafetensorsFileMetadata"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-post_init of SafetensorsFileMetadata","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5],"arg_names":["metadata","tensors","parameter_count"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"huggingface_hub.utils._safetensors.SafetensorsFileMetadata.__mypy-replace","name":"__mypy-replace","original_first_arg":"metadata","type":{".class":"CallableType","arg_kinds":[5,5,5],"arg_names":["metadata","tensors","parameter_count"],"arg_types":[{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str","huggingface_hub.utils._safetensors.TensorInfo"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.utils._safetensors.DTYPE_T"},"builtins.int"],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of SafetensorsFileMetadata","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"huggingface_hub.utils._safetensors.SafetensorsFileMetadata.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5],"arg_names":["metadata","tensors","parameter_count"],"arg_types":[{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str","huggingface_hub.utils._safetensors.TensorInfo"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.utils._safetensors.DTYPE_T"},"builtins.int"],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of SafetensorsFileMetadata","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"__post_init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.utils._safetensors.SafetensorsFileMetadata.__post_init__","name":"__post_init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.utils._safetensors.SafetensorsFileMetadata"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__post_init__ of SafetensorsFileMetadata","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"metadata":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.utils._safetensors.SafetensorsFileMetadata.metadata","name":"metadata","setter_type":null,"type":{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"parameter_count":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.utils._safetensors.SafetensorsFileMetadata.parameter_count","name":"parameter_count","setter_type":null,"type":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.utils._safetensors.DTYPE_T"},"builtins.int"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"tensors":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.utils._safetensors.SafetensorsFileMetadata.tensors","name":"tensors","setter_type":null,"type":{".class":"Instance","args":["builtins.str","huggingface_hub.utils._safetensors.TensorInfo"],"extra_attrs":null,"type_ref":"builtins.dict"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.utils._safetensors.SafetensorsFileMetadata.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.utils._safetensors.SafetensorsFileMetadata","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"SafetensorsRepoMetadata":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.utils._safetensors.SafetensorsRepoMetadata","name":"SafetensorsRepoMetadata","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._safetensors.SafetensorsRepoMetadata","has_param_spec_type":false,"metaclass_type":null,"metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":100,"name":"metadata","type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":101,"name":"sharded","type":"builtins.bool"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":102,"name":"weight_map","type":{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":103,"name":"files_metadata","type":{".class":"Instance","args":["builtins.str","huggingface_hub.utils._safetensors.SafetensorsFileMetadata"],"extra_attrs":null,"type_ref":"builtins.dict"}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":104,"name":"parameter_count","type":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.utils._safetensors.DTYPE_T"},"builtins.int"],"extra_attrs":null,"type_ref":"builtins.dict"}}],"frozen":false},"dataclass_tag":{}},"module_name":"huggingface_hub.utils._safetensors","mro":["huggingface_hub.utils._safetensors.SafetensorsRepoMetadata","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"huggingface_hub.utils._safetensors.SafetensorsRepoMetadata.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"dataclasses.Field"}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0],"arg_names":["self","metadata","sharded","weight_map","files_metadata"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._safetensors.SafetensorsRepoMetadata.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":["self","metadata","sharded","weight_map","files_metadata"],"arg_types":["huggingface_hub.utils._safetensors.SafetensorsRepoMetadata",{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool",{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str","huggingface_hub.utils._safetensors.SafetensorsFileMetadata"],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of SafetensorsRepoMetadata","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-post_init":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._safetensors.SafetensorsRepoMetadata.__mypy-post_init","name":"__mypy-post_init","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.utils._safetensors.SafetensorsRepoMetadata"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-post_init of SafetensorsRepoMetadata","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5],"arg_names":["metadata","sharded","weight_map","files_metadata","parameter_count"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"huggingface_hub.utils._safetensors.SafetensorsRepoMetadata.__mypy-replace","name":"__mypy-replace","original_first_arg":"metadata","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5],"arg_names":["metadata","sharded","weight_map","files_metadata","parameter_count"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool",{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str","huggingface_hub.utils._safetensors.SafetensorsFileMetadata"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.utils._safetensors.DTYPE_T"},"builtins.int"],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of SafetensorsRepoMetadata","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"huggingface_hub.utils._safetensors.SafetensorsRepoMetadata.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5],"arg_names":["metadata","sharded","weight_map","files_metadata","parameter_count"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool",{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str","huggingface_hub.utils._safetensors.SafetensorsFileMetadata"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.utils._safetensors.DTYPE_T"},"builtins.int"],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of SafetensorsRepoMetadata","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"__post_init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.utils._safetensors.SafetensorsRepoMetadata.__post_init__","name":"__post_init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.utils._safetensors.SafetensorsRepoMetadata"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__post_init__ of SafetensorsRepoMetadata","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"files_metadata":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.utils._safetensors.SafetensorsRepoMetadata.files_metadata","name":"files_metadata","setter_type":null,"type":{".class":"Instance","args":["builtins.str","huggingface_hub.utils._safetensors.SafetensorsFileMetadata"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"metadata":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.utils._safetensors.SafetensorsRepoMetadata.metadata","name":"metadata","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"parameter_count":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.utils._safetensors.SafetensorsRepoMetadata.parameter_count","name":"parameter_count","setter_type":null,"type":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.utils._safetensors.DTYPE_T"},"builtins.int"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"sharded":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.utils._safetensors.SafetensorsRepoMetadata.sharded","name":"sharded","setter_type":null,"type":"builtins.bool"}},"weight_map":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.utils._safetensors.SafetensorsRepoMetadata.weight_map","name":"weight_map","setter_type":null,"type":{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.utils._safetensors.SafetensorsRepoMetadata.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.utils._safetensors.SafetensorsRepoMetadata","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TENSOR_NAME_T":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.utils._safetensors.TENSOR_NAME_T","line":9,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":"builtins.str"}},"TensorInfo":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.utils._safetensors.TensorInfo","name":"TensorInfo","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._safetensors.TensorInfo","has_param_spec_type":false,"metaclass_type":null,"metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":30,"name":"dtype","type":{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.utils._safetensors.DTYPE_T"}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":31,"name":"shape","type":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.list"}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":32,"name":"data_offsets","type":{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}},{"alias":null,"column":4,"has_default":false,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":33,"name":"parameter_count","type":"builtins.int"}],"frozen":false},"dataclass_tag":{}},"module_name":"huggingface_hub.utils._safetensors","mro":["huggingface_hub.utils._safetensors.TensorInfo","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"huggingface_hub.utils._safetensors.TensorInfo.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"dataclasses.Field"}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","dtype","shape","data_offsets"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._safetensors.TensorInfo.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","dtype","shape","data_offsets"],"arg_types":["huggingface_hub.utils._safetensors.TensorInfo",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.utils._safetensors.DTYPE_T"},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of TensorInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-post_init":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._safetensors.TensorInfo.__mypy-post_init","name":"__mypy-post_init","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.utils._safetensors.TensorInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-post_init of TensorInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5],"arg_names":["dtype","shape","data_offsets","parameter_count"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"huggingface_hub.utils._safetensors.TensorInfo.__mypy-replace","name":"__mypy-replace","original_first_arg":"dtype","type":{".class":"CallableType","arg_kinds":[5,5,5,5],"arg_names":["dtype","shape","data_offsets","parameter_count"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.utils._safetensors.DTYPE_T"},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of TensorInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"huggingface_hub.utils._safetensors.TensorInfo.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5],"arg_names":["dtype","shape","data_offsets","parameter_count"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.utils._safetensors.DTYPE_T"},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of TensorInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"__post_init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.utils._safetensors.TensorInfo.__post_init__","name":"__post_init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["huggingface_hub.utils._safetensors.TensorInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__post_init__ of TensorInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"data_offsets":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.utils._safetensors.TensorInfo.data_offsets","name":"data_offsets","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"dtype":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.utils._safetensors.TensorInfo.dtype","name":"dtype","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.utils._safetensors.DTYPE_T"}}},"parameter_count":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"huggingface_hub.utils._safetensors.TensorInfo.parameter_count","name":"parameter_count","setter_type":null,"type":"builtins.int"}},"shape":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"huggingface_hub.utils._safetensors.TensorInfo.shape","name":"shape","setter_type":null,"type":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.list"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.utils._safetensors.TensorInfo.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.utils._safetensors.TensorInfo","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._safetensors.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._safetensors.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._safetensors.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._safetensors.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._safetensors.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._safetensors.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"dataclass":{".class":"SymbolTableNode","cross_ref":"dataclasses.dataclass","kind":"Gdef"},"defaultdict":{".class":"SymbolTableNode","cross_ref":"collections.defaultdict","kind":"Gdef"},"field":{".class":"SymbolTableNode","cross_ref":"dataclasses.field","kind":"Gdef"},"functools":{".class":"SymbolTableNode","cross_ref":"functools","kind":"Gdef"},"operator":{".class":"SymbolTableNode","cross_ref":"operator","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_safetensors.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_safetensors.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_safetensors.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..2dd71cf6eff075ca7d311f155e39e476afb14e85 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_safetensors.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106714,"dep_lines":[1,2,3,4,5,1,1,1,1,1],"dep_prios":[10,10,5,5,5,5,30,30,30,30],"dependencies":["functools","operator","collections","dataclasses","typing","builtins","_frozen_importlib","abc","enum","typing_extensions"],"hash":"466e4a87473fe64cb1f5849461ec0be8890bb6e6","id":"huggingface_hub.utils._safetensors","ignore_all":true,"interface_hash":"e1c7935ff6acc19bf54f9ed935bf4b48951ddcb4","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_safetensors.py","plugin_data":null,"size":4439,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_subprocess.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_subprocess.data.json new file mode 100644 index 0000000000000000000000000000000000000000..bda0763784c03d1aed60ab4c9e7038a4c8a2425c --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_subprocess.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.utils._subprocess","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Generator":{".class":"SymbolTableNode","cross_ref":"typing.Generator","kind":"Gdef"},"IO":{".class":"SymbolTableNode","cross_ref":"typing.IO","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"Path":{".class":"SymbolTableNode","cross_ref":"pathlib.Path","kind":"Gdef"},"StringIO":{".class":"SymbolTableNode","cross_ref":"_io.StringIO","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._subprocess.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._subprocess.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._subprocess.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._subprocess.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._subprocess.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._subprocess.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"capture_output":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated"],"fullname":"huggingface_hub.utils._subprocess.capture_output","name":"capture_output","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"capture_output","ret_type":{".class":"Instance","args":["_io.StringIO",{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Generator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.utils._subprocess.capture_output","name":"capture_output","setter_type":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"capture_output","ret_type":{".class":"Instance","args":["_io.StringIO",{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"contextmanager":{".class":"SymbolTableNode","cross_ref":"contextlib.contextmanager","kind":"Gdef"},"get_logger":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils.logging.get_logger","kind":"Gdef"},"logger":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._subprocess.logger","name":"logger","setter_type":null,"type":"logging.Logger"}},"os":{".class":"SymbolTableNode","cross_ref":"os","kind":"Gdef"},"run_interactive_subprocess":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,4],"arg_names":["command","folder","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated"],"fullname":"huggingface_hub.utils._subprocess.run_interactive_subprocess","name":"run_interactive_subprocess","original_first_arg":"command","type":{".class":"CallableType","arg_kinds":[0,1,4],"arg_names":["command","folder","kwargs"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str","pathlib.Path",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"run_interactive_subprocess","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.IO"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.IO"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Generator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.utils._subprocess.run_interactive_subprocess","name":"run_interactive_subprocess","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,4],"arg_names":["command","folder","kwargs"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str","pathlib.Path",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"run_interactive_subprocess","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.IO"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.IO"}],"partial_fallback":{".class":"Instance","args":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.IO"}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"run_subprocess":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,4],"arg_names":["command","folder","check","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._subprocess.run_subprocess","name":"run_subprocess","original_first_arg":"command","type":{".class":"CallableType","arg_kinds":[0,1,1,4],"arg_names":["command","folder","check","kwargs"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str","pathlib.Path",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"run_subprocess","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"subprocess.CompletedProcess"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"subprocess":{".class":"SymbolTableNode","cross_ref":"subprocess","kind":"Gdef"},"sys":{".class":"SymbolTableNode","cross_ref":"sys","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_subprocess.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_subprocess.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_subprocess.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..a158289ef54a46fe29ffa67e357938c2faf2f382 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_subprocess.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[25,17,18,19,20,21,22,23,1,1,1,1,1],"dep_prios":[5,10,10,10,5,5,5,5,5,30,30,30,30],"dependencies":["huggingface_hub.utils.logging","os","subprocess","sys","contextlib","io","pathlib","typing","builtins","_frozen_importlib","_io","abc","logging"],"hash":"5e19bd2cc4222c1676326ac2148000c74371dbc3","id":"huggingface_hub.utils._subprocess","ignore_all":true,"interface_hash":"ba8dd1a8926c31ca3f5bfe920a8fc62de82572fb","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_subprocess.py","plugin_data":null,"size":4612,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_telemetry.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_telemetry.data.json new file mode 100644 index 0000000000000000000000000000000000000000..9225b3a5b1deed2fcfe0382f99472f97ad47a568 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_telemetry.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.utils._telemetry","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Lock":{".class":"SymbolTableNode","cross_ref":"threading.Lock","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"Queue":{".class":"SymbolTableNode","cross_ref":"queue.Queue","kind":"Gdef"},"Thread":{".class":"SymbolTableNode","cross_ref":"threading.Thread","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"_TELEMETRY_QUEUE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"huggingface_hub.utils._telemetry._TELEMETRY_QUEUE","name":"_TELEMETRY_QUEUE","setter_type":null,"type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"queue.Queue"}}},"_TELEMETRY_THREAD":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"huggingface_hub.utils._telemetry._TELEMETRY_THREAD","name":"_TELEMETRY_THREAD","setter_type":null,"type":{".class":"UnionType","items":["threading.Thread",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"_TELEMETRY_THREAD_LOCK":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._telemetry._TELEMETRY_THREAD_LOCK","name":"_TELEMETRY_THREAD_LOCK","setter_type":null,"type":"_thread.LockType"}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._telemetry.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._telemetry.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._telemetry.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._telemetry.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._telemetry.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._telemetry.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_send_telemetry_in_thread":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5],"arg_names":["topic","library_name","library_version","user_agent"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._telemetry._send_telemetry_in_thread","name":"_send_telemetry_in_thread","original_first_arg":"topic","type":{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":["topic","library_name","library_version","user_agent"],"arg_types":["builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_send_telemetry_in_thread","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_start_telemetry_thread":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._telemetry._start_telemetry_thread","name":"_start_telemetry_thread","original_first_arg":null,"type":null}},"_telemetry_worker":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._telemetry._telemetry_worker","name":"_telemetry_worker","original_first_arg":null,"type":null}},"build_hf_headers":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._headers.build_hf_headers","kind":"Gdef"},"constants":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.constants","kind":"Gdef"},"get_session":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._http.get_session","kind":"Gdef"},"hf_raise_for_status":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._http.hf_raise_for_status","kind":"Gdef"},"logger":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._telemetry.logger","name":"logger","setter_type":null,"type":"logging.Logger"}},"logging":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils.logging","kind":"Gdef"},"quote":{".class":"SymbolTableNode","cross_ref":"urllib.parse.quote","kind":"Gdef"},"send_telemetry":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5],"arg_names":["topic","library_name","library_version","user_agent"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._telemetry.send_telemetry","name":"send_telemetry","original_first_arg":"topic","type":{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":["topic","library_name","library_version","user_agent"],"arg_types":["builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"send_telemetry","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_telemetry.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_telemetry.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_telemetry.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..7b90c8f244363d6e498fb2d1b27de7e541136e04 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_telemetry.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[4,6,7,1,2,3,6,1,1,1,1,1,1],"dep_prios":[5,10,5,5,5,5,5,5,30,30,30,30,30],"dependencies":["urllib.parse","huggingface_hub.constants","huggingface_hub.utils","queue","threading","typing","huggingface_hub","builtins","_frozen_importlib","_thread","abc","huggingface_hub.utils.logging","logging"],"hash":"cce5e5f83ecb9651a0b99be7fc2678fc6c55f03e","id":"huggingface_hub.utils._telemetry","ignore_all":true,"interface_hash":"879969cf9c24a1dcb232eb72edc0c5eec4ef170e","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_telemetry.py","plugin_data":null,"size":4881,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_terminal.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_terminal.data.json new file mode 100644 index 0000000000000000000000000000000000000000..0b20800903d34ccac7dba8a2fe1cf24716c78c5f --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_terminal.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.utils._terminal","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","ANSI":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.utils._terminal.ANSI","name":"ANSI","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._terminal.ANSI","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.utils._terminal","mro":["huggingface_hub.utils._terminal.ANSI","builtins.object"],"names":{".class":"SymbolTable","_bold":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._terminal.ANSI._bold","name":"_bold","setter_type":null,"type":"builtins.str"}},"_format":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["cls","s","code"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.utils._terminal.ANSI._format","name":"_format","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["cls","s","code"],"arg_types":[{".class":"TypeType","item":"huggingface_hub.utils._terminal.ANSI"},"builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_format of ANSI","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"huggingface_hub.utils._terminal.ANSI._format","name":"_format","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["cls","s","code"],"arg_types":[{".class":"TypeType","item":"huggingface_hub.utils._terminal.ANSI"},"builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_format of ANSI","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"_gray":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._terminal.ANSI._gray","name":"_gray","setter_type":null,"type":"builtins.str"}},"_red":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._terminal.ANSI._red","name":"_red","setter_type":null,"type":"builtins.str"}},"_reset":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._terminal.ANSI._reset","name":"_reset","setter_type":null,"type":"builtins.str"}},"_yellow":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._terminal.ANSI._yellow","name":"_yellow","setter_type":null,"type":"builtins.str"}},"bold":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","s"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.utils._terminal.ANSI.bold","name":"bold","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","s"],"arg_types":[{".class":"TypeType","item":"huggingface_hub.utils._terminal.ANSI"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"bold of ANSI","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"huggingface_hub.utils._terminal.ANSI.bold","name":"bold","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","s"],"arg_types":[{".class":"TypeType","item":"huggingface_hub.utils._terminal.ANSI"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"bold of ANSI","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"gray":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","s"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.utils._terminal.ANSI.gray","name":"gray","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","s"],"arg_types":[{".class":"TypeType","item":"huggingface_hub.utils._terminal.ANSI"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"gray of ANSI","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"huggingface_hub.utils._terminal.ANSI.gray","name":"gray","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","s"],"arg_types":[{".class":"TypeType","item":"huggingface_hub.utils._terminal.ANSI"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"gray of ANSI","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"red":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","s"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.utils._terminal.ANSI.red","name":"red","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","s"],"arg_types":[{".class":"TypeType","item":"huggingface_hub.utils._terminal.ANSI"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"red of ANSI","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"huggingface_hub.utils._terminal.ANSI.red","name":"red","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","s"],"arg_types":[{".class":"TypeType","item":"huggingface_hub.utils._terminal.ANSI"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"red of ANSI","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"yellow":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","s"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"huggingface_hub.utils._terminal.ANSI.yellow","name":"yellow","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","s"],"arg_types":[{".class":"TypeType","item":"huggingface_hub.utils._terminal.ANSI"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"yellow of ANSI","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"huggingface_hub.utils._terminal.ANSI.yellow","name":"yellow","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","s"],"arg_types":[{".class":"TypeType","item":"huggingface_hub.utils._terminal.ANSI"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"yellow of ANSI","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.utils._terminal.ANSI.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.utils._terminal.ANSI","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._terminal.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._terminal.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._terminal.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._terminal.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._terminal.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._terminal.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"os":{".class":"SymbolTableNode","cross_ref":"os","kind":"Gdef"},"tabulate":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["rows","headers"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._terminal.tabulate","name":"tabulate","original_first_arg":"rows","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["rows","headers"],"arg_types":[{".class":"Instance","args":[{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str","builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tabulate","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_terminal.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_terminal.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_terminal.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..ba5141d008c8ae5b7a2f24b010801c32b22df236 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_terminal.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106714,"dep_lines":[16,17,1,1,1],"dep_prios":[10,5,5,30,30],"dependencies":["os","typing","builtins","_frozen_importlib","abc"],"hash":"24f93afc8f4bb593130ff42e04cc88248f8510da","id":"huggingface_hub.utils._terminal","ignore_all":true,"interface_hash":"ca48e3d178ec1d166c6b2f207a60265d4f75b76a","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_terminal.py","plugin_data":null,"size":2115,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_typing.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_typing.data.json new file mode 100644 index 0000000000000000000000000000000000000000..ec38d4c82c60be82859ed43d6863c2f4840fb1b9 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_typing.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.utils._typing","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"CallableT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.utils._typing.CallableT","name":"CallableT","upper_bound":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"values":[],"variance":0}},"HTTP_METHOD_T":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.utils._typing.HTTP_METHOD_T","line":28,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"GET"},{".class":"LiteralType","fallback":"builtins.str","value":"OPTIONS"},{".class":"LiteralType","fallback":"builtins.str","value":"HEAD"},{".class":"LiteralType","fallback":"builtins.str","value":"POST"},{".class":"LiteralType","fallback":"builtins.str","value":"PUT"},{".class":"LiteralType","fallback":"builtins.str","value":"PATCH"},{".class":"LiteralType","fallback":"builtins.str","value":"DELETE"}],"uses_pep604_syntax":false}}},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"Type":{".class":"SymbolTableNode","cross_ref":"typing.Type","kind":"Gdef"},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef"},"UNION_TYPES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"huggingface_hub.utils._typing.UNION_TYPES","name":"UNION_TYPES","setter_type":null,"type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"}}},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"_JSON_SERIALIZABLE_TYPES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._typing._JSON_SERIALIZABLE_TYPES","name":"_JSON_SERIALIZABLE_TYPES","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":[{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[1],"arg_names":[null],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.ConvertibleToInt"}],"fallback":"builtins.type","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":"int","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"base"],"arg_types":[{".class":"UnionType","items":["builtins.str","builtins.bytes","builtins.bytearray"],"uses_pep604_syntax":false},"typing.SupportsIndex"],"fallback":"builtins.type","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":"int","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]},{".class":"CallableType","arg_kinds":[1],"arg_names":[null],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.ConvertibleToFloat"}],"fallback":"builtins.type","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":"float","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[1],"arg_names":["object"],"arg_types":["builtins.object"],"fallback":"abc.ABCMeta","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":"str","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["object","encoding","errors"],"arg_types":["typing_extensions.Buffer","builtins.str","builtins.str"],"fallback":"abc.ABCMeta","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":"str","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]},{".class":"CallableType","arg_kinds":[1],"arg_names":[null],"arg_types":["builtins.object"],"fallback":"builtins.type","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":"bool","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"TypeType","item":{".class":"NoneType"}}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._typing.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._typing.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._typing.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._typing.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._typing.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._typing.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"get_args":{".class":"SymbolTableNode","cross_ref":"typing.get_args","kind":"Gdef"},"get_origin":{".class":"SymbolTableNode","cross_ref":"typing.get_origin","kind":"Gdef"},"is_jsonable":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["obj","_visited"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._typing.is_jsonable","name":"is_jsonable","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["obj","_visited"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_jsonable","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_simple_optional_type":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["type_"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._typing.is_simple_optional_type","name":"is_simple_optional_type","original_first_arg":"type_","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["type_"],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_simple_optional_type","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"sys":{".class":"SymbolTableNode","cross_ref":"sys","kind":"Gdef"},"unwrap_simple_optional_type":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["optional_type"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._typing.unwrap_simple_optional_type","name":"unwrap_simple_optional_type","original_first_arg":"optional_type","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["optional_type"],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unwrap_simple_optional_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_typing.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_typing.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_typing.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..120dd10ecfb8c8492ec449939beb7583b648d1da --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_typing.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106714,"dep_lines":[17,18,1,1,1,1,1],"dep_prios":[10,5,5,30,30,30,30],"dependencies":["sys","typing","builtins","_frozen_importlib","_typeshed","abc","typing_extensions"],"hash":"ed4344140d49410b388d9bf0182af7cd5e074530","id":"huggingface_hub.utils._typing","ignore_all":true,"interface_hash":"6a2546390a7a215423e0ce9976800b2dffdc376e","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_typing.py","plugin_data":null,"size":3617,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_validators.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_validators.data.json new file mode 100644 index 0000000000000000000000000000000000000000..eaa5f3264760d7c5042cfe7b9b58ae27fc60704b --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_validators.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.utils._validators","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"CallableT":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._typing.CallableT","kind":"Gdef"},"HFValidationError":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.errors.HFValidationError","kind":"Gdef"},"REPO_ID_REGEX":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._validators.REPO_ID_REGEX","name":"REPO_ID_REGEX","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._validators.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._validators.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._validators.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._validators.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._validators.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._validators.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"chain":{".class":"SymbolTableNode","cross_ref":"itertools.chain","kind":"Gdef"},"inspect":{".class":"SymbolTableNode","cross_ref":"inspect","kind":"Gdef"},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef"},"smoothly_deprecate_legacy_arguments":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["fn_name","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._validators.smoothly_deprecate_legacy_arguments","name":"smoothly_deprecate_legacy_arguments","original_first_arg":"fn_name","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["fn_name","kwargs"],"arg_types":["builtins.str",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"smoothly_deprecate_legacy_arguments","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"validate_hf_hub_args":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["fn"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._validators.validate_hf_hub_args","name":"validate_hf_hub_args","original_first_arg":"fn","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["fn"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.utils._typing.CallableT","id":-1,"name":"CallableT","namespace":"huggingface_hub.utils._validators.validate_hf_hub_args","upper_bound":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate_hf_hub_args","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.utils._typing.CallableT","id":-1,"name":"CallableT","namespace":"huggingface_hub.utils._validators.validate_hf_hub_args","upper_bound":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.utils._typing.CallableT","id":-1,"name":"CallableT","namespace":"huggingface_hub.utils._validators.validate_hf_hub_args","upper_bound":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"values":[],"variance":0}]}}},"validate_repo_id":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["repo_id"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._validators.validate_repo_id","name":"validate_repo_id","original_first_arg":"repo_id","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["repo_id"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate_repo_id","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"warnings":{".class":"SymbolTableNode","cross_ref":"warnings","kind":"Gdef"},"wraps":{".class":"SymbolTableNode","cross_ref":"functools.wraps","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_validators.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_validators.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_validators.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..7887ce7e0c8213999643501efc3904e44cf4b3ee --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_validators.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106718,"dep_lines":[26,24,17,18,19,20,21,22,1,1,1,1],"dep_prios":[5,5,10,10,10,5,5,5,5,30,30,30],"dependencies":["huggingface_hub.utils._typing","huggingface_hub.errors","inspect","re","warnings","functools","itertools","typing","builtins","_frozen_importlib","abc","enum"],"hash":"f7fc4552c9739d26a15a540716edab9a4a4a6c1a","id":"huggingface_hub.utils._validators","ignore_all":true,"interface_hash":"08686c5430bb9b0416f07b24d24391af1ab22486","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_validators.py","plugin_data":null,"size":8346,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_verification.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_verification.data.json new file mode 100644 index 0000000000000000000000000000000000000000..06a58adbfc1ebe8be8a06d23ca1a4aa82d0c975f --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_verification.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.utils._verification","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","FolderVerification":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.utils._verification.FolderVerification","name":"FolderVerification","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._verification.FolderVerification","has_param_spec_type":false,"metaclass_type":null,"metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":31,"name":"revision","type":"builtins.str"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":32,"name":"checked_count","type":"builtins.int"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":33,"name":"mismatches","type":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.utils._verification.Mismatch"}],"extra_attrs":null,"type_ref":"builtins.list"}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":34,"name":"missing_paths","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":35,"name":"extra_paths","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":36,"name":"verified_path","type":"pathlib.Path"}],"frozen":true},"dataclass_tag":{}},"module_name":"huggingface_hub.utils._verification","mro":["huggingface_hub.utils._verification.FolderVerification","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"huggingface_hub.utils._verification.FolderVerification.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"dataclasses.Field"}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0,0,0],"arg_names":["self","revision","checked_count","mismatches","missing_paths","extra_paths","verified_path"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._verification.FolderVerification.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,0],"arg_names":["self","revision","checked_count","mismatches","missing_paths","extra_paths","verified_path"],"arg_types":["huggingface_hub.utils._verification.FolderVerification","builtins.str","builtins.int",{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.utils._verification.Mismatch"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},"pathlib.Path"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of FolderVerification","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5],"arg_names":["revision","checked_count","mismatches","missing_paths","extra_paths","verified_path"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"huggingface_hub.utils._verification.FolderVerification.__mypy-replace","name":"__mypy-replace","original_first_arg":"revision","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5],"arg_names":["revision","checked_count","mismatches","missing_paths","extra_paths","verified_path"],"arg_types":["builtins.str","builtins.int",{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.utils._verification.Mismatch"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},"pathlib.Path"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of FolderVerification","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"huggingface_hub.utils._verification.FolderVerification.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5],"arg_names":["revision","checked_count","mismatches","missing_paths","extra_paths","verified_path"],"arg_types":["builtins.str","builtins.int",{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.utils._verification.Mismatch"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},"pathlib.Path"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of FolderVerification","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"checked_count":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._verification.FolderVerification.checked_count","name":"checked_count","setter_type":null,"type":"builtins.int"}},"extra_paths":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._verification.FolderVerification.extra_paths","name":"extra_paths","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"mismatches":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._verification.FolderVerification.mismatches","name":"mismatches","setter_type":null,"type":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.utils._verification.Mismatch"}],"extra_attrs":null,"type_ref":"builtins.list"}}},"missing_paths":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._verification.FolderVerification.missing_paths","name":"missing_paths","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"revision":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._verification.FolderVerification.revision","name":"revision","setter_type":null,"type":"builtins.str"}},"verified_path":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._verification.FolderVerification.verified_path","name":"verified_path","setter_type":null,"type":"pathlib.Path"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.utils._verification.FolderVerification.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.utils._verification.FolderVerification","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"HashAlgo":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"huggingface_hub.utils._verification.HashAlgo","line":26,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"sha256"},{".class":"LiteralType","fallback":"builtins.str","value":"git-sha1"}],"uses_pep604_syntax":false}}},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"Mismatch":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.utils._verification.Mismatch","name":"Mismatch","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._verification.Mismatch","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.utils._verification","mro":["huggingface_hub.utils._verification.Mismatch","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["path","builtins.str"],["expected","builtins.str"],["actual","builtins.str"],["algorithm","builtins.str"]],"readonly_keys":[],"required_keys":["actual","algorithm","expected","path"]}}},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"Path":{".class":"SymbolTableNode","cross_ref":"pathlib.Path","kind":"Gdef"},"RepoFile":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.hf_api.RepoFile","kind":"Gdef"},"RepoFolder":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.hf_api.RepoFolder","kind":"Gdef"},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"TypedDict":{".class":"SymbolTableNode","cross_ref":"typing.TypedDict","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"_REGEX_COMMIT_HASH":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._verification._REGEX_COMMIT_HASH","name":"_REGEX_COMMIT_HASH","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._verification.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._verification.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._verification.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._verification.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._verification.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._verification.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_resolve_commit_hash_from_cache":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["storage_folder","revision"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._verification._resolve_commit_hash_from_cache","name":"_resolve_commit_hash_from_cache","original_first_arg":"storage_folder","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["storage_folder","revision"],"arg_types":["pathlib.Path",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_resolve_commit_hash_from_cache","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"collect_local_files":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["root"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._verification.collect_local_files","name":"collect_local_files","original_first_arg":"root","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["root"],"arg_types":["pathlib.Path"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"collect_local_files","ret_type":{".class":"Instance","args":["builtins.str","pathlib.Path"],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"compute_file_hash":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["path","algorithm"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._verification.compute_file_hash","name":"compute_file_hash","original_first_arg":"path","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["path","algorithm"],"arg_types":["pathlib.Path",{".class":"TypeAliasType","args":[],"type_ref":"huggingface_hub.utils._verification.HashAlgo"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"compute_file_hash","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"constants":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.constants","kind":"Gdef"},"dataclass":{".class":"SymbolTableNode","cross_ref":"dataclasses.dataclass","kind":"Gdef"},"git_hash":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils.sha.git_hash","kind":"Gdef"},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef"},"repo_folder_name":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.file_download.repo_folder_name","kind":"Gdef"},"resolve_local_root":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3,3,3,3],"arg_names":["repo_id","repo_type","revision","cache_dir","local_dir"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._verification.resolve_local_root","name":"resolve_local_root","original_first_arg":"repo_id","type":{".class":"CallableType","arg_kinds":[3,3,3,3,3],"arg_names":["repo_id","repo_type","revision","cache_dir","local_dir"],"arg_types":["builtins.str","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["pathlib.Path",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["pathlib.Path",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"resolve_local_root","ret_type":{".class":"TupleType","implicit":false,"items":["pathlib.Path","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"sha_fileobj":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils.sha.sha_fileobj","kind":"Gdef"},"verify_maps":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3,3,3],"arg_names":["remote_by_path","local_by_path","revision","verified_path"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._verification.verify_maps","name":"verify_maps","original_first_arg":"remote_by_path","type":{".class":"CallableType","arg_kinds":[3,3,3,3],"arg_names":["remote_by_path","local_by_path","revision","verified_path"],"arg_types":[{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["huggingface_hub.hf_api.RepoFile","huggingface_hub.hf_api.RepoFolder"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str","pathlib.Path"],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.str","pathlib.Path"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"verify_maps","ret_type":"huggingface_hub.utils._verification.FolderVerification","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_verification.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_verification.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_verification.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..57f85a2f19eea3df7b041eb0fbdeba8aa69758e9 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_verification.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[8,6,7,12,1,2,3,4,6,1,1,1,1,1],"dep_prios":[5,10,5,25,10,5,5,5,20,5,30,30,30,30],"dependencies":["huggingface_hub.utils.sha","huggingface_hub.constants","huggingface_hub.file_download","huggingface_hub.hf_api","re","dataclasses","pathlib","typing","huggingface_hub","builtins","_frozen_importlib","abc","enum","os"],"hash":"fed845d5285ae92a6a284c223fda5ae3548c8dcc","id":"huggingface_hub.utils._verification","ignore_all":true,"interface_hash":"0507acc239c40c579ad86bc22dbe20e862e7ab9d","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_verification.py","plugin_data":null,"size":5496,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_xet.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_xet.data.json new file mode 100644 index 0000000000000000000000000000000000000000..1993167a7bad32b8d67b8c8fdf0295d707d802f4 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_xet.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.utils._xet","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Enum":{".class":"SymbolTableNode","cross_ref":"enum.Enum","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"XET_CONNECTION_INFO_CACHE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"huggingface_hub.utils._xet.XET_CONNECTION_INFO_CACHE","name":"XET_CONNECTION_INFO_CACHE","setter_type":null,"type":{".class":"Instance","args":["builtins.str","huggingface_hub.utils._xet.XetConnectionInfo"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"XET_CONNECTION_INFO_CACHE_SIZE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._xet.XET_CONNECTION_INFO_CACHE_SIZE","name":"XET_CONNECTION_INFO_CACHE_SIZE","setter_type":null,"type":"builtins.int"}},"XET_CONNECTION_INFO_SAFETY_PERIOD":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._xet.XET_CONNECTION_INFO_SAFETY_PERIOD","name":"XET_CONNECTION_INFO_SAFETY_PERIOD","setter_type":null,"type":"builtins.int"}},"XetConnectionInfo":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.utils._xet.XetConnectionInfo","name":"XetConnectionInfo","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._xet.XetConnectionInfo","has_param_spec_type":false,"metaclass_type":null,"metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":30,"name":"access_token","type":"builtins.str"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":31,"name":"expiration_unix_epoch","type":"builtins.int"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":32,"name":"endpoint","type":"builtins.str"}],"frozen":true},"dataclass_tag":{}},"module_name":"huggingface_hub.utils._xet","mro":["huggingface_hub.utils._xet.XetConnectionInfo","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"huggingface_hub.utils._xet.XetConnectionInfo.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"dataclasses.Field"}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","access_token","expiration_unix_epoch","endpoint"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._xet.XetConnectionInfo.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","access_token","expiration_unix_epoch","endpoint"],"arg_types":["huggingface_hub.utils._xet.XetConnectionInfo","builtins.str","builtins.int","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of XetConnectionInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5],"arg_names":["access_token","expiration_unix_epoch","endpoint"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"huggingface_hub.utils._xet.XetConnectionInfo.__mypy-replace","name":"__mypy-replace","original_first_arg":"access_token","type":{".class":"CallableType","arg_kinds":[5,5,5],"arg_names":["access_token","expiration_unix_epoch","endpoint"],"arg_types":["builtins.str","builtins.int","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of XetConnectionInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"huggingface_hub.utils._xet.XetConnectionInfo.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5],"arg_names":["access_token","expiration_unix_epoch","endpoint"],"arg_types":["builtins.str","builtins.int","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of XetConnectionInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"access_token":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._xet.XetConnectionInfo.access_token","name":"access_token","setter_type":null,"type":"builtins.str"}},"endpoint":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._xet.XetConnectionInfo.endpoint","name":"endpoint","setter_type":null,"type":"builtins.str"}},"expiration_unix_epoch":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._xet.XetConnectionInfo.expiration_unix_epoch","name":"expiration_unix_epoch","setter_type":null,"type":"builtins.int"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.utils._xet.XetConnectionInfo.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.utils._xet.XetConnectionInfo","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"XetFileData":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.utils._xet.XetFileData","name":"XetFileData","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._xet.XetFileData","has_param_spec_type":false,"metaclass_type":null,"metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":24,"name":"file_hash","type":"builtins.str"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":25,"name":"refresh_route","type":"builtins.str"}],"frozen":true},"dataclass_tag":{}},"module_name":"huggingface_hub.utils._xet","mro":["huggingface_hub.utils._xet.XetFileData","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"huggingface_hub.utils._xet.XetFileData.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"dataclasses.Field"}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","file_hash","refresh_route"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._xet.XetFileData.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","file_hash","refresh_route"],"arg_types":["huggingface_hub.utils._xet.XetFileData","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of XetFileData","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5],"arg_names":["file_hash","refresh_route"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"huggingface_hub.utils._xet.XetFileData.__mypy-replace","name":"__mypy-replace","original_first_arg":"file_hash","type":{".class":"CallableType","arg_kinds":[5,5],"arg_names":["file_hash","refresh_route"],"arg_types":["builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of XetFileData","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"huggingface_hub.utils._xet.XetFileData.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5],"arg_names":["file_hash","refresh_route"],"arg_types":["builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of XetFileData","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"file_hash":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._xet.XetFileData.file_hash","name":"file_hash","setter_type":null,"type":"builtins.str"}},"refresh_route":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"huggingface_hub.utils._xet.XetFileData.refresh_route","name":"refresh_route","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.utils._xet.XetFileData.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.utils._xet.XetFileData","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"XetTokenType":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.str","enum.Enum"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.utils._xet.XetTokenType","name":"XetTokenType","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_enum"],"fullname":"huggingface_hub.utils._xet.XetTokenType","has_param_spec_type":false,"metaclass_type":"enum.EnumMeta","metadata":{},"module_name":"huggingface_hub.utils._xet","mro":["huggingface_hub.utils._xet.XetTokenType","builtins.str","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","enum.Enum","builtins.object"],"names":{".class":"SymbolTable","READ":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._xet.XetTokenType.READ","name":"READ","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.str","value":"read"},"type_ref":"builtins.str"}}},"WRITE":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils._xet.XetTokenType.WRITE","name":"WRITE","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.str","value":"write"},"type_ref":"builtins.str"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.utils._xet.XetTokenType.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.utils._xet.XetTokenType","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._xet.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._xet.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._xet.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._xet.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._xet.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils._xet.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_cache_key":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["url","headers","params"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._xet._cache_key","name":"_cache_key","original_first_arg":"url","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["url","headers","params"],"arg_types":["builtins.str",{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_cache_key","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_fetch_xet_connection_info_with_url":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["url","headers","params"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated"],"fullname":"huggingface_hub.utils._xet._fetch_xet_connection_info_with_url","name":"_fetch_xet_connection_info_with_url","original_first_arg":"url","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["url","headers","params"],"arg_types":["builtins.str",{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_fetch_xet_connection_info_with_url","ret_type":"huggingface_hub.utils._xet.XetConnectionInfo","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.utils._xet._fetch_xet_connection_info_with_url","name":"_fetch_xet_connection_info_with_url","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["url","headers","params"],"arg_types":["builtins.str",{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_fetch_xet_connection_info_with_url","ret_type":"huggingface_hub.utils._xet.XetConnectionInfo","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"_is_expired":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["connection_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._xet._is_expired","name":"_is_expired","original_first_arg":"connection_info","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["connection_info"],"arg_types":["huggingface_hub.utils._xet.XetConnectionInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_is_expired","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"constants":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.constants","kind":"Gdef"},"dataclass":{".class":"SymbolTableNode","cross_ref":"dataclasses.dataclass","kind":"Gdef"},"fetch_xet_connection_info_from_repo_info":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3,3,5,3,5,5],"arg_names":["token_type","repo_id","repo_type","revision","headers","endpoint","params"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated"],"fullname":"huggingface_hub.utils._xet.fetch_xet_connection_info_from_repo_info","name":"fetch_xet_connection_info_from_repo_info","original_first_arg":"token_type","type":{".class":"CallableType","arg_kinds":[3,3,3,5,3,5,5],"arg_names":["token_type","repo_id","repo_type","revision","headers","endpoint","params"],"arg_types":["huggingface_hub.utils._xet.XetTokenType","builtins.str","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fetch_xet_connection_info_from_repo_info","ret_type":"huggingface_hub.utils._xet.XetConnectionInfo","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.utils._xet.fetch_xet_connection_info_from_repo_info","name":"fetch_xet_connection_info_from_repo_info","setter_type":null,"type":{".class":"CallableType","arg_kinds":[3,3,3,5,3,5,5],"arg_names":["token_type","repo_id","repo_type","revision","headers","endpoint","params"],"arg_types":["huggingface_hub.utils._xet.XetTokenType","builtins.str","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fetch_xet_connection_info_from_repo_info","ret_type":"huggingface_hub.utils._xet.XetConnectionInfo","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"get_session":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._http.get_session","kind":"Gdef"},"hf_raise_for_status":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._http.hf_raise_for_status","kind":"Gdef"},"httpx":{".class":"SymbolTableNode","cross_ref":"httpx","kind":"Gdef"},"parse_xet_connection_info_from_headers":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["headers"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._xet.parse_xet_connection_info_from_headers","name":"parse_xet_connection_info_from_headers","original_first_arg":"headers","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["headers"],"arg_types":[{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parse_xet_connection_info_from_headers","ret_type":{".class":"UnionType","items":["huggingface_hub.utils._xet.XetConnectionInfo",{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"parse_xet_file_data_from_response":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["response","endpoint"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils._xet.parse_xet_file_data_from_response","name":"parse_xet_file_data_from_response","original_first_arg":"response","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["response","endpoint"],"arg_types":["httpx._models.Response",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parse_xet_file_data_from_response","ret_type":{".class":"UnionType","items":["huggingface_hub.utils._xet.XetFileData",{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"refresh_xet_connection_info":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3],"arg_names":["file_data","headers"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated"],"fullname":"huggingface_hub.utils._xet.refresh_xet_connection_info","name":"refresh_xet_connection_info","original_first_arg":"file_data","type":{".class":"CallableType","arg_kinds":[3,3],"arg_names":["file_data","headers"],"arg_types":["huggingface_hub.utils._xet.XetFileData",{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"refresh_xet_connection_info","ret_type":"huggingface_hub.utils._xet.XetConnectionInfo","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.utils._xet.refresh_xet_connection_info","name":"refresh_xet_connection_info","setter_type":null,"type":{".class":"CallableType","arg_kinds":[3,3],"arg_names":["file_data","headers"],"arg_types":["huggingface_hub.utils._xet.XetFileData",{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"refresh_xet_connection_info","ret_type":"huggingface_hub.utils._xet.XetConnectionInfo","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"time":{".class":"SymbolTableNode","cross_ref":"time","kind":"Gdef"},"validate_hf_hub_args":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils._validators.validate_hf_hub_args","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_xet.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_xet.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_xet.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..e06497d933053278b75abdf3ca148867a8a79c2a --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/_xet.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[8,9,1,2,3,4,6,8,1,1,1,1,1],"dep_prios":[10,5,10,5,5,5,10,20,5,30,30,30,30],"dependencies":["huggingface_hub.constants","huggingface_hub.utils","time","dataclasses","enum","typing","httpx","huggingface_hub","builtins","_frozen_importlib","abc","httpx._models","huggingface_hub.utils._validators"],"hash":"70e69f69636c48e53805faae6580520a6c0c21d3","id":"huggingface_hub.utils._xet","ignore_all":true,"interface_hash":"20b07ac09abcd85f14aa045c3a30b25dfec7b1b0","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/_xet.py","plugin_data":null,"size":8896,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/endpoint_helpers.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/endpoint_helpers.data.json new file mode 100644 index 0000000000000000000000000000000000000000..c4c9aa780a8e3e30695aeef889fa1665a4632911 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/endpoint_helpers.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.utils.endpoint_helpers","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","ModelCardData":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.repocard_data.ModelCardData","kind":"Gdef"},"ModelInfo":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.hf_api.ModelInfo","kind":"Gdef"},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.endpoint_helpers.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.endpoint_helpers.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.endpoint_helpers.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.endpoint_helpers.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.endpoint_helpers.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.endpoint_helpers.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_is_emission_within_threshold":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["model_info","minimum_threshold","maximum_threshold"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils.endpoint_helpers._is_emission_within_threshold","name":"_is_emission_within_threshold","original_first_arg":"model_info","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["model_info","minimum_threshold","maximum_threshold"],"arg_types":["huggingface_hub.hf_api.ModelInfo","builtins.float","builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_is_emission_within_threshold","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"math":{".class":"SymbolTableNode","cross_ref":"math","kind":"Gdef"},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/endpoint_helpers.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/endpoint_helpers.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/endpoint_helpers.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..ca81306e28346300554899e83ec4222ececa2663 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/endpoint_helpers.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[21,25,17,18,19,1,1,1],"dep_prios":[5,25,10,10,5,5,30,30],"dependencies":["huggingface_hub.repocard_data","huggingface_hub.hf_api","math","re","typing","builtins","_frozen_importlib","abc"],"hash":"302889148cbe52be0209056f3a49544e55248510","id":"huggingface_hub.utils.endpoint_helpers","ignore_all":true,"interface_hash":"9a9304fb5160155d911300dc970f897af5b4880c","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/endpoint_helpers.py","plugin_data":null,"size":2366,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/insecure_hashlib.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/insecure_hashlib.data.json new file mode 100644 index 0000000000000000000000000000000000000000..9b4fbb57d4470650ca54f93a429825cae0416804 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/insecure_hashlib.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.utils.insecure_hashlib","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.insecure_hashlib.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.insecure_hashlib.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.insecure_hashlib.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.insecure_hashlib.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.insecure_hashlib.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.insecure_hashlib.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"functools":{".class":"SymbolTableNode","cross_ref":"functools","kind":"Gdef"},"hashlib":{".class":"SymbolTableNode","cross_ref":"hashlib","kind":"Gdef"},"md5":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils.insecure_hashlib.md5","name":"md5","setter_type":null,"type":{".class":"Instance","args":["_hashlib.HASH"],"extra_attrs":{".class":"ExtraAttrs","attrs":{"__mypy_partial":{".class":"CallableType","arg_kinds":[1,5],"arg_names":["string","usedforsecurity"],"arg_types":["typing_extensions.Buffer","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"openssl_md5","ret_type":"_hashlib.HASH","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"immutable":[],"mod_name":null},"type_ref":"functools.partial"}}},"sha1":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils.insecure_hashlib.sha1","name":"sha1","setter_type":null,"type":{".class":"Instance","args":["_hashlib.HASH"],"extra_attrs":{".class":"ExtraAttrs","attrs":{"__mypy_partial":{".class":"CallableType","arg_kinds":[1,5],"arg_names":["string","usedforsecurity"],"arg_types":["typing_extensions.Buffer","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"openssl_sha1","ret_type":"_hashlib.HASH","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"immutable":[],"mod_name":null},"type_ref":"functools.partial"}}},"sha256":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils.insecure_hashlib.sha256","name":"sha256","setter_type":null,"type":{".class":"Instance","args":["_hashlib.HASH"],"extra_attrs":{".class":"ExtraAttrs","attrs":{"__mypy_partial":{".class":"CallableType","arg_kinds":[1,5],"arg_names":["string","usedforsecurity"],"arg_types":["typing_extensions.Buffer","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"openssl_sha256","ret_type":"_hashlib.HASH","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"immutable":[],"mod_name":null},"type_ref":"functools.partial"}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/insecure_hashlib.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/insecure_hashlib.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/insecure_hashlib.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..1ee28e83254637fd577bd190b2368df40a71dace --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/insecure_hashlib.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106714,"dep_lines":[26,27,1,1,1,1,1,1],"dep_prios":[10,10,5,30,30,30,30,30],"dependencies":["functools","hashlib","builtins","_frozen_importlib","_hashlib","abc","typing","typing_extensions"],"hash":"921fbc59769fd6f44a9dccf009ccaf84abb700e3","id":"huggingface_hub.utils.insecure_hashlib","ignore_all":true,"interface_hash":"f8f84a24a2b60751a617dab83276e227b64804f1","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/insecure_hashlib.py","plugin_data":null,"size":1008,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/logging.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/logging.data.json new file mode 100644 index 0000000000000000000000000000000000000000..eb17c8eb0ed8e883357c1f0e7763532a638c2a76 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/logging.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.utils.logging","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","CRITICAL":{".class":"SymbolTableNode","cross_ref":"logging.CRITICAL","kind":"Gdef"},"DEBUG":{".class":"SymbolTableNode","cross_ref":"logging.DEBUG","kind":"Gdef"},"ERROR":{".class":"SymbolTableNode","cross_ref":"logging.ERROR","kind":"Gdef"},"FATAL":{".class":"SymbolTableNode","cross_ref":"logging.FATAL","kind":"Gdef"},"INFO":{".class":"SymbolTableNode","cross_ref":"logging.INFO","kind":"Gdef"},"NOTSET":{".class":"SymbolTableNode","cross_ref":"logging.NOTSET","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"WARN":{".class":"SymbolTableNode","cross_ref":"logging.WARN","kind":"Gdef"},"WARNING":{".class":"SymbolTableNode","cross_ref":"logging.WARNING","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.logging.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.logging.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.logging.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.logging.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.logging.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.logging.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_configure_library_root_logger":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils.logging._configure_library_root_logger","name":"_configure_library_root_logger","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_configure_library_root_logger","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_default_log_level":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils.logging._default_log_level","name":"_default_log_level","setter_type":null,"type":"builtins.int"}},"_get_default_logging_level":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils.logging._get_default_logging_level","name":"_get_default_logging_level","original_first_arg":null,"type":null}},"_get_library_name":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils.logging._get_library_name","name":"_get_library_name","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_library_name","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_get_library_root_logger":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils.logging._get_library_root_logger","name":"_get_library_root_logger","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_library_root_logger","ret_type":"logging.Logger","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_reset_library_root_logger":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils.logging._reset_library_root_logger","name":"_reset_library_root_logger","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_reset_library_root_logger","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"constants":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.constants","kind":"Gdef"},"disable_propagation":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils.logging.disable_propagation","name":"disable_propagation","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"disable_propagation","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"enable_propagation":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils.logging.enable_propagation","name":"enable_propagation","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"enable_propagation","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_logger":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1],"arg_names":["name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils.logging.get_logger","name":"get_logger","original_first_arg":"name","type":{".class":"CallableType","arg_kinds":[1],"arg_names":["name"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_logger","ret_type":"logging.Logger","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_verbosity":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils.logging.get_verbosity","name":"get_verbosity","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_verbosity","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"log_levels":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"huggingface_hub.utils.logging.log_levels","name":"log_levels","setter_type":null,"type":{".class":"Instance","args":["builtins.str","builtins.int"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"logging":{".class":"SymbolTableNode","cross_ref":"logging","kind":"Gdef"},"os":{".class":"SymbolTableNode","cross_ref":"os","kind":"Gdef"},"set_verbosity":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["verbosity"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils.logging.set_verbosity","name":"set_verbosity","original_first_arg":"verbosity","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["verbosity"],"arg_types":["builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"set_verbosity","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"set_verbosity_debug":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils.logging.set_verbosity_debug","name":"set_verbosity_debug","original_first_arg":null,"type":null}},"set_verbosity_error":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils.logging.set_verbosity_error","name":"set_verbosity_error","original_first_arg":null,"type":null}},"set_verbosity_info":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils.logging.set_verbosity_info","name":"set_verbosity_info","original_first_arg":null,"type":null}},"set_verbosity_warning":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils.logging.set_verbosity_warning","name":"set_verbosity_warning","original_first_arg":null,"type":null}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/logging.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/logging.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/logging.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..6652fc7d59d288821af249444ced859be60ef3e0 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/logging.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106721,"dep_lines":[31,17,18,29,31,1,1,1],"dep_prios":[10,5,10,5,20,5,30,30],"dependencies":["huggingface_hub.constants","logging","os","typing","huggingface_hub","builtins","_frozen_importlib","abc"],"hash":"1d8acf9a2fd587c737846568ccfc1b6cde3aa461","id":"huggingface_hub.utils.logging","ignore_all":true,"interface_hash":"cb93bb88b5193c9f667c328b1bb56a4e03c0f92a","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/logging.py","plugin_data":null,"size":4916,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/sha.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/sha.data.json new file mode 100644 index 0000000000000000000000000000000000000000..2ead09c9c995972ab629ce77202607c8d5bee7fa --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/sha.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.utils.sha","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","BinaryIO":{".class":"SymbolTableNode","cross_ref":"typing.BinaryIO","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.sha.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.sha.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.sha.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.sha.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.sha.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.sha.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"git_hash":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["data"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils.sha.git_hash","name":"git_hash","original_first_arg":"data","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["data"],"arg_types":["builtins.bytes"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"git_hash","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"sha1":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils.insecure_hashlib.sha1","kind":"Gdef"},"sha256":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.utils.insecure_hashlib.sha256","kind":"Gdef"},"sha_fileobj":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["fileobj","chunk_size"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils.sha.sha_fileobj","name":"sha_fileobj","original_first_arg":"fileobj","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["fileobj","chunk_size"],"arg_types":["typing.BinaryIO",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sha_fileobj","ret_type":"builtins.bytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/sha.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/sha.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/sha.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..85eff3670a0d5bdd8ec5b97e70395f38aeb18ca8 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/sha.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[5,3,1,1,1],"dep_prios":[5,5,5,30,30],"dependencies":["huggingface_hub.utils.insecure_hashlib","typing","builtins","_frozen_importlib","abc"],"hash":"cadf3829fbfcebf37bd8baf570163f93ce14b8f6","id":"huggingface_hub.utils.sha","ignore_all":true,"interface_hash":"3b14a0df23bac78d08f5963d77707a1d0380151f","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/sha.py","plugin_data":null,"size":2134,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/tqdm.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/tqdm.data.json new file mode 100644 index 0000000000000000000000000000000000000000..88d2807f10e92a39b8abb3a63320985b52bc4ff3 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/tqdm.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"huggingface_hub.utils.tqdm","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","ContextManager":{".class":"SymbolTableNode","cross_ref":"typing.ContextManager","kind":"Gdef"},"HF_HUB_DISABLE_PROGRESS_BARS":{".class":"SymbolTableNode","cross_ref":"huggingface_hub.constants.HF_HUB_DISABLE_PROGRESS_BARS","kind":"Gdef"},"Iterator":{".class":"SymbolTableNode","cross_ref":"typing.Iterator","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"Path":{".class":"SymbolTableNode","cross_ref":"pathlib.Path","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.tqdm.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.tqdm.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.tqdm.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.tqdm.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.tqdm.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"huggingface_hub.utils.tqdm.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_get_progress_bar_context":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3,5,5,5,5,5,5,5],"arg_names":["desc","log_level","total","initial","unit","unit_scale","name","tqdm_class","_tqdm_bar"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils.tqdm._get_progress_bar_context","name":"_get_progress_bar_context","original_first_arg":"desc","type":{".class":"CallableType","arg_kinds":[3,3,5,5,5,5,5,5,5],"arg_names":["desc","log_level","total","initial","unit","unit_scale","name","tqdm_class","_tqdm_bar"],"arg_types":["builtins.str","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.int","builtins.str","builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"huggingface_hub.utils.tqdm.old_tqdm","source_any":null,"type_of_any":3}},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["huggingface_hub.utils.tqdm.tqdm",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_progress_bar_context","ret_type":{".class":"Instance","args":["huggingface_hub.utils.tqdm.tqdm"],"extra_attrs":null,"type_ref":"typing.ContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"are_progress_bars_disabled":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1],"arg_names":["name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils.tqdm.are_progress_bars_disabled","name":"are_progress_bars_disabled","original_first_arg":"name","type":{".class":"CallableType","arg_kinds":[1],"arg_names":["name"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"are_progress_bars_disabled","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"contextmanager":{".class":"SymbolTableNode","cross_ref":"contextlib.contextmanager","kind":"Gdef"},"disable_progress_bars":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1],"arg_names":["name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils.tqdm.disable_progress_bars","name":"disable_progress_bars","original_first_arg":"name","type":{".class":"CallableType","arg_kinds":[1],"arg_names":["name"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"disable_progress_bars","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"enable_progress_bars":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1],"arg_names":["name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils.tqdm.enable_progress_bars","name":"enable_progress_bars","original_first_arg":"name","type":{".class":"CallableType","arg_kinds":[1],"arg_names":["name"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"enable_progress_bars","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"io":{".class":"SymbolTableNode","cross_ref":"io","kind":"Gdef"},"is_tqdm_disabled":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["log_level"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils.tqdm.is_tqdm_disabled","name":"is_tqdm_disabled","original_first_arg":"log_level","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["log_level"],"arg_types":["builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_tqdm_disabled","ret_type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"logging":{".class":"SymbolTableNode","cross_ref":"logging","kind":"Gdef"},"nullcontext":{".class":"SymbolTableNode","cross_ref":"contextlib.nullcontext","kind":"Gdef"},"old_tqdm":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"huggingface_hub.utils.tqdm.old_tqdm","name":"old_tqdm","setter_type":null,"type":{".class":"AnyType","missing_import_name":"huggingface_hub.utils.tqdm.old_tqdm","source_any":null,"type_of_any":3}}},"os":{".class":"SymbolTableNode","cross_ref":"os","kind":"Gdef"},"progress_bar_states":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"huggingface_hub.utils.tqdm.progress_bar_states","name":"progress_bar_states","setter_type":null,"type":{".class":"Instance","args":["builtins.str","builtins.bool"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"tqdm":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"huggingface_hub.utils.tqdm.tqdm","name":"tqdm","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["fallback_to_any"],"fullname":"huggingface_hub.utils.tqdm.tqdm","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"huggingface_hub.utils.tqdm","mro":["huggingface_hub.utils.tqdm.tqdm","builtins.object"],"names":{".class":"SymbolTable","__delattr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"huggingface_hub.utils.tqdm.tqdm.__delattr__","name":"__delattr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["huggingface_hub.utils.tqdm.tqdm","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__delattr__ of tqdm","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"huggingface_hub.utils.tqdm.tqdm.__init__","name":"__init__","original_first_arg":"self","type":null}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"huggingface_hub.utils.tqdm.tqdm.Self","id":0,"name":"Self","namespace":"","upper_bound":"huggingface_hub.utils.tqdm.tqdm","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"tqdm_stream_file":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["path"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated"],"fullname":"huggingface_hub.utils.tqdm.tqdm_stream_file","name":"tqdm_stream_file","original_first_arg":"path","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["path"],"arg_types":[{".class":"UnionType","items":["pathlib.Path","builtins.str"],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tqdm_stream_file","ret_type":{".class":"Instance","args":[{".class":"Instance","args":["_io._BufferedReaderStream"],"extra_attrs":null,"type_ref":"_io.BufferedReader"}],"extra_attrs":null,"type_ref":"typing.Iterator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"huggingface_hub.utils.tqdm.tqdm_stream_file","name":"tqdm_stream_file","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["path"],"arg_types":[{".class":"UnionType","items":["pathlib.Path","builtins.str"],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tqdm_stream_file","ret_type":{".class":"Instance","args":[{".class":"Instance","args":["_io._BufferedReaderStream"],"extra_attrs":null,"type_ref":"_io.BufferedReader"},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"warnings":{".class":"SymbolTableNode","cross_ref":"warnings","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/tqdm.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/tqdm.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/tqdm.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..49fab54f0adf9a0d6efb92cf5b91cedb82efb3c9 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/huggingface_hub/utils/tqdm.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[93,83,84,85,86,87,88,89,1,1,1,1,91],"dep_prios":[5,10,10,10,10,5,5,5,5,30,30,30,5],"dependencies":["huggingface_hub.constants","io","logging","os","warnings","contextlib","pathlib","typing","builtins","_frozen_importlib","_io","abc"],"hash":"73529a4ecf222515551cc7c700c81ad27fe525d2","id":"huggingface_hub.utils.tqdm","ignore_all":true,"interface_hash":"0bd334e61a52f491cf3cbea804591da72711b33c","mtime":1763542609,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":true,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/huggingface_hub/utils/tqdm.py","plugin_data":null,"size":10757,"suppressed":["tqdm.auto"],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/importlib/metadata/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/importlib/metadata/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..88da9afd5896a2c686ac9e45d885b1fbb15be519 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/importlib/metadata/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"importlib.metadata","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"ClassVar":{".class":"SymbolTableNode","cross_ref":"typing.ClassVar","kind":"Gdef","module_hidden":true,"module_public":false},"Distribution":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[["locate_file",1],["read_text",1]],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"importlib.metadata.Distribution","name":"Distribution","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_abstract"],"fullname":"importlib.metadata.Distribution","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"importlib.metadata","mro":["importlib.metadata.Distribution","builtins.object"],"names":{".class":"SymbolTable","at":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["path"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"importlib.metadata.Distribution.at","name":"at","original_first_arg":"path","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["path"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.StrPath"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"at of Distribution","ret_type":"importlib.metadata.PathDistribution","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_staticmethod","is_ready","is_inferred"],"fullname":"importlib.metadata.Distribution.at","name":"at","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["path"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.StrPath"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"at of Distribution","ret_type":"importlib.metadata.PathDistribution","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"discover":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":["is_class"],"fullname":"importlib.metadata.Distribution.discover","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3],"arg_names":["cls","context"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_overload","is_decorated","is_trivial_self"],"fullname":"importlib.metadata.Distribution.discover","name":"discover","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,3],"arg_names":["cls","context"],"arg_types":[{".class":"TypeType","item":"importlib.metadata.Distribution"},"importlib.metadata.DistributionFinder.Context"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"discover of Distribution","ret_type":{".class":"Instance","args":["importlib.metadata.Distribution"],"extra_attrs":null,"type_ref":"typing.Iterable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_classmethod","is_ready","is_inferred"],"fullname":"importlib.metadata.Distribution.discover","name":"discover","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,3],"arg_names":["cls","context"],"arg_types":[{".class":"TypeType","item":"importlib.metadata.Distribution"},"importlib.metadata.DistributionFinder.Context"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"discover of Distribution","ret_type":{".class":"Instance","args":["importlib.metadata.Distribution"],"extra_attrs":null,"type_ref":"typing.Iterable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,4],"arg_names":["cls","context","name","path","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_overload","is_decorated","is_trivial_self"],"fullname":"importlib.metadata.Distribution.discover","name":"discover","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,5,5,5,4],"arg_names":["cls","context","name","path","kwargs"],"arg_types":[{".class":"TypeType","item":"importlib.metadata.Distribution"},{".class":"NoneType"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"discover of Distribution","ret_type":{".class":"Instance","args":["importlib.metadata.Distribution"],"extra_attrs":null,"type_ref":"typing.Iterable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_classmethod","is_ready","is_inferred"],"fullname":"importlib.metadata.Distribution.discover","name":"discover","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5,5,4],"arg_names":["cls","context","name","path","kwargs"],"arg_types":[{".class":"TypeType","item":"importlib.metadata.Distribution"},{".class":"NoneType"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"discover of Distribution","ret_type":{".class":"Instance","args":["importlib.metadata.Distribution"],"extra_attrs":null,"type_ref":"typing.Iterable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,3],"arg_names":["cls","context"],"arg_types":[{".class":"TypeType","item":"importlib.metadata.Distribution"},"importlib.metadata.DistributionFinder.Context"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"discover of Distribution","ret_type":{".class":"Instance","args":["importlib.metadata.Distribution"],"extra_attrs":null,"type_ref":"typing.Iterable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,5,5,5,4],"arg_names":["cls","context","name","path","kwargs"],"arg_types":[{".class":"TypeType","item":"importlib.metadata.Distribution"},{".class":"NoneType"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"discover of Distribution","ret_type":{".class":"Instance","args":["importlib.metadata.Distribution"],"extra_attrs":null,"type_ref":"typing.Iterable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"entry_points":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"importlib.metadata.Distribution.entry_points","name":"entry_points","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["importlib.metadata.Distribution"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"entry_points of Distribution","ret_type":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"importlib.metadata.EntryPoint"}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"importlib.metadata.Distribution.entry_points","name":"entry_points","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["importlib.metadata.Distribution"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"entry_points of Distribution","ret_type":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"importlib.metadata.EntryPoint"}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"files":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"importlib.metadata.Distribution.files","name":"files","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["importlib.metadata.Distribution"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"files of Distribution","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["importlib.metadata.PackagePath"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"importlib.metadata.Distribution.files","name":"files","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["importlib.metadata.Distribution"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"files of Distribution","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["importlib.metadata.PackagePath"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"from_name":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","name"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"importlib.metadata.Distribution.from_name","name":"from_name","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","name"],"arg_types":[{".class":"TypeType","item":"importlib.metadata.Distribution"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"from_name of Distribution","ret_type":"importlib.metadata.Distribution","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"importlib.metadata.Distribution.from_name","name":"from_name","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","name"],"arg_types":[{".class":"TypeType","item":"importlib.metadata.Distribution"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"from_name of Distribution","ret_type":"importlib.metadata.Distribution","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"locate_file":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":1,"arg_kinds":[0,0],"arg_names":["self","path"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated","is_trivial_self"],"fullname":"importlib.metadata.Distribution.locate_file","name":"locate_file","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","path"],"arg_types":["importlib.metadata.Distribution",{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.StrPath"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"locate_file of Distribution","ret_type":"pathlib.Path","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred"],"fullname":"importlib.metadata.Distribution.locate_file","name":"locate_file","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","path"],"arg_types":["importlib.metadata.Distribution",{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.StrPath"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"locate_file of Distribution","ret_type":"pathlib.Path","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"metadata":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"importlib.metadata.Distribution.metadata","name":"metadata","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["importlib.metadata.Distribution"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"metadata of Distribution","ret_type":{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"email.message.Message"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"importlib.metadata.Distribution.metadata","name":"metadata","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["importlib.metadata.Distribution"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"metadata of Distribution","ret_type":{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"email.message.Message"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"read_text":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":1,"arg_kinds":[0,0],"arg_names":["self","filename"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated","is_trivial_self"],"fullname":"importlib.metadata.Distribution.read_text","name":"read_text","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","filename"],"arg_types":["importlib.metadata.Distribution","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"read_text of Distribution","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred"],"fullname":"importlib.metadata.Distribution.read_text","name":"read_text","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","filename"],"arg_types":["importlib.metadata.Distribution","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"read_text of Distribution","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"requires":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"importlib.metadata.Distribution.requires","name":"requires","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["importlib.metadata.Distribution"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"requires of Distribution","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"importlib.metadata.Distribution.requires","name":"requires","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["importlib.metadata.Distribution"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"requires of Distribution","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"version":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"importlib.metadata.Distribution.version","name":"version","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["importlib.metadata.Distribution"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"version of Distribution","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"importlib.metadata.Distribution.version","name":"version","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["importlib.metadata.Distribution"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"version of Distribution","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"DistributionFinder":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[["find_distributions",1]],"alt_promote":null,"bases":["importlib.abc.MetaPathFinder"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"importlib.metadata.DistributionFinder","name":"DistributionFinder","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_abstract"],"fullname":"importlib.metadata.DistributionFinder","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"importlib.metadata","mro":["importlib.metadata.DistributionFinder","importlib.abc.MetaPathFinder","importlib.abc.Finder","builtins.object"],"names":{".class":"SymbolTable","Context":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"importlib.metadata.DistributionFinder.Context","name":"Context","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"importlib.metadata.DistributionFinder.Context","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"importlib.metadata","mro":["importlib.metadata.DistributionFinder.Context","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,4],"arg_names":["self","name","path","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"importlib.metadata.DistributionFinder.Context.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,5,4],"arg_names":["self","name","path","kwargs"],"arg_types":["importlib.metadata.DistributionFinder.Context",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of Context","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"name":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"importlib.metadata.DistributionFinder.Context.name","name":"name","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"path":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"importlib.metadata.DistributionFinder.Context.path","name":"path","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["importlib.metadata.DistributionFinder.Context"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"path of Context","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"importlib.metadata.DistributionFinder.Context.path","name":"path","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["importlib.metadata.DistributionFinder.Context"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"path of Context","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"find_distributions":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":1,"arg_kinds":[0,1],"arg_names":["self","context"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated","is_trivial_self"],"fullname":"importlib.metadata.DistributionFinder.find_distributions","name":"find_distributions","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","context"],"arg_types":["importlib.metadata.DistributionFinder","importlib.metadata.DistributionFinder.Context"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"find_distributions of DistributionFinder","ret_type":{".class":"Instance","args":["importlib.metadata.Distribution"],"extra_attrs":null,"type_ref":"typing.Iterable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred"],"fullname":"importlib.metadata.DistributionFinder.find_distributions","name":"find_distributions","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","context"],"arg_types":["importlib.metadata.DistributionFinder","importlib.metadata.DistributionFinder.Context"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"find_distributions of DistributionFinder","ret_type":{".class":"Instance","args":["importlib.metadata.Distribution"],"extra_attrs":null,"type_ref":"typing.Iterable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"EntryPoint":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["importlib.metadata._EntryPointBase"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"importlib.metadata.EntryPoint","name":"EntryPoint","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_disjoint_base"],"fullname":"importlib.metadata.EntryPoint","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"importlib.metadata","mro":["importlib.metadata.EntryPoint","importlib.metadata._EntryPointBase","builtins.tuple","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","__hash__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"importlib.metadata.EntryPoint.__hash__","name":"__hash__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":"importlib.metadata.EntryPoint"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__hash__ of EntryPoint","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__iter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"importlib.metadata.EntryPoint.__iter__","name":"__iter__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":"importlib.metadata.EntryPoint"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iter__ of EntryPoint","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Iterator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"attr":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"importlib.metadata.EntryPoint.attr","name":"attr","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":"importlib.metadata.EntryPoint"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"attr of EntryPoint","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"importlib.metadata.EntryPoint.attr","name":"attr","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":"importlib.metadata.EntryPoint"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"attr of EntryPoint","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"extras":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"importlib.metadata.EntryPoint.extras","name":"extras","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":"importlib.metadata.EntryPoint"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"extras of EntryPoint","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"importlib.metadata.EntryPoint.extras","name":"extras","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":"importlib.metadata.EntryPoint"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"extras of EntryPoint","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"load":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"importlib.metadata.EntryPoint.load","name":"load","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":"importlib.metadata.EntryPoint"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"load of EntryPoint","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"module":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"importlib.metadata.EntryPoint.module","name":"module","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":"importlib.metadata.EntryPoint"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"module of EntryPoint","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"importlib.metadata.EntryPoint.module","name":"module","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":"importlib.metadata.EntryPoint"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"module of EntryPoint","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"pattern":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready"],"fullname":"importlib.metadata.EntryPoint.pattern","name":"pattern","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}}},"self_type":null,"slots":null,"tuple_type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":"importlib.metadata._EntryPointBase"},"type_vars":[],"typeddict_type":null}},"FileHash":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"importlib.metadata.FileHash","name":"FileHash","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"importlib.metadata.FileHash","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"importlib.metadata","mro":["importlib.metadata.FileHash","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","spec"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"importlib.metadata.FileHash.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","spec"],"arg_types":["importlib.metadata.FileHash","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of FileHash","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"mode":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"importlib.metadata.FileHash.mode","name":"mode","setter_type":null,"type":"builtins.str"}},"value":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"importlib.metadata.FileHash.value","name":"value","setter_type":null,"type":"builtins.str"}}},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Generic":{".class":"SymbolTableNode","cross_ref":"typing.Generic","kind":"Gdef","module_hidden":true,"module_public":false},"Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef","module_hidden":true,"module_public":false},"Iterator":{".class":"SymbolTableNode","cross_ref":"typing.Iterator","kind":"Gdef","module_hidden":true,"module_public":false},"Mapping":{".class":"SymbolTableNode","cross_ref":"typing.Mapping","kind":"Gdef","module_hidden":true,"module_public":false},"Message":{".class":"SymbolTableNode","cross_ref":"email.message.Message","kind":"Gdef","module_hidden":true,"module_public":false},"MetaPathFinder":{".class":"SymbolTableNode","cross_ref":"importlib.abc.MetaPathFinder","kind":"Gdef","module_hidden":true,"module_public":false},"MetadataPathFinder":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["importlib.metadata.DistributionFinder"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"importlib.metadata.MetadataPathFinder","name":"MetadataPathFinder","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"importlib.metadata.MetadataPathFinder","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"importlib.metadata","mro":["importlib.metadata.MetadataPathFinder","importlib.metadata.DistributionFinder","importlib.abc.MetaPathFinder","importlib.abc.Finder","builtins.object"],"names":{".class":"SymbolTable","find_distributions":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["cls","context"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"importlib.metadata.MetadataPathFinder.find_distributions","name":"find_distributions","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["cls","context"],"arg_types":[{".class":"TypeType","item":"importlib.metadata.MetadataPathFinder"},"importlib.metadata.DistributionFinder.Context"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"find_distributions of MetadataPathFinder","ret_type":{".class":"Instance","args":["importlib.metadata.PathDistribution"],"extra_attrs":null,"type_ref":"typing.Iterable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"importlib.metadata.MetadataPathFinder.find_distributions","name":"find_distributions","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["cls","context"],"arg_types":[{".class":"TypeType","item":"importlib.metadata.MetadataPathFinder"},"importlib.metadata.DistributionFinder.Context"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"find_distributions of MetadataPathFinder","ret_type":{".class":"Instance","args":["importlib.metadata.PathDistribution"],"extra_attrs":null,"type_ref":"typing.Iterable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"NamedTuple":{".class":"SymbolTableNode","cross_ref":"typing.NamedTuple","kind":"Gdef","module_hidden":true,"module_public":false},"PackageNotFoundError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.ModuleNotFoundError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"importlib.metadata.PackageNotFoundError","name":"PackageNotFoundError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"importlib.metadata.PackageNotFoundError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"importlib.metadata","mro":["importlib.metadata.PackageNotFoundError","builtins.ModuleNotFoundError","builtins.ImportError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","name":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"importlib.metadata.PackageNotFoundError.name","name":"name","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["importlib.metadata.PackageNotFoundError"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"name of PackageNotFoundError","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"importlib.metadata.PackageNotFoundError.name","name":"name","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["importlib.metadata.PackageNotFoundError"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"name of PackageNotFoundError","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"PackagePath":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pathlib.PurePosixPath"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"importlib.metadata.PackagePath","name":"PackagePath","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"importlib.metadata.PackagePath","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"importlib.metadata","mro":["importlib.metadata.PackagePath","pathlib.PurePosixPath","pathlib.PurePath","os.PathLike","abc.ABC","builtins.object"],"names":{".class":"SymbolTable","dist":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"importlib.metadata.PackagePath.dist","name":"dist","setter_type":null,"type":"importlib.metadata.Distribution"}},"hash":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"importlib.metadata.PackagePath.hash","name":"hash","setter_type":null,"type":{".class":"UnionType","items":["importlib.metadata.FileHash",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"locate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"importlib.metadata.PackagePath.locate","name":"locate","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["importlib.metadata.PackagePath"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"locate of PackagePath","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"os.PathLike"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"read_binary":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"importlib.metadata.PackagePath.read_binary","name":"read_binary","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["importlib.metadata.PackagePath"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"read_binary of PackagePath","ret_type":"builtins.bytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"read_text":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","encoding"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"importlib.metadata.PackagePath.read_text","name":"read_text","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","encoding"],"arg_types":["importlib.metadata.PackagePath","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"read_text of PackagePath","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"size":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"importlib.metadata.PackagePath.size","name":"size","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}}}},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Path":{".class":"SymbolTableNode","cross_ref":"pathlib.Path","kind":"Gdef","module_hidden":true,"module_public":false},"PathDistribution":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["importlib.metadata.Distribution"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"importlib.metadata.PathDistribution","name":"PathDistribution","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"importlib.metadata.PathDistribution","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"importlib.metadata","mro":["importlib.metadata.PathDistribution","importlib.metadata.Distribution","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","path"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"importlib.metadata.PathDistribution.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","path"],"arg_types":["importlib.metadata.PathDistribution","pathlib.Path"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of PathDistribution","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_path":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"importlib.metadata.PathDistribution._path","name":"_path","setter_type":null,"type":"pathlib.Path"}},"locate_file":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","path"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"importlib.metadata.PathDistribution.locate_file","name":"locate_file","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","path"],"arg_types":["importlib.metadata.PathDistribution",{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.StrPath"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"locate_file of PathDistribution","ret_type":"pathlib.Path","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"read_text":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","filename"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"importlib.metadata.PathDistribution.read_text","name":"read_text","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","filename"],"arg_types":["importlib.metadata.PathDistribution",{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.StrPath"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"read_text of PathDistribution","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"PathLike":{".class":"SymbolTableNode","cross_ref":"os.PathLike","kind":"Gdef","module_hidden":true,"module_public":false},"Pattern":{".class":"SymbolTableNode","cross_ref":"re.Pattern","kind":"Gdef","module_hidden":true,"module_public":false},"Self":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Self","kind":"Gdef","module_hidden":true,"module_public":false},"StrPath":{".class":"SymbolTableNode","cross_ref":"_typeshed.StrPath","kind":"Gdef","module_hidden":true,"module_public":false},"TypeAlias":{".class":"SymbolTableNode","cross_ref":"typing_extensions.TypeAlias","kind":"Gdef","module_hidden":true,"module_public":false},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"_EntryPointBase":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"importlib.metadata._EntryPointBase","name":"_EntryPointBase","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_named_tuple"],"fullname":"importlib.metadata._EntryPointBase","has_param_spec_type":false,"metaclass_type":null,"metadata":{"namedtuple":{"fields":["name","value","group"]}},"module_name":"importlib.metadata","mro":["importlib.metadata._EntryPointBase","builtins.tuple","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","_NT":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"importlib.metadata._EntryPointBase._NT","name":"_NT","upper_bound":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},"__annotations__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"importlib.metadata._EntryPointBase.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"importlib.metadata._EntryPointBase.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__new__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["_cls","name","value","group"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static"],"fullname":"importlib.metadata._EntryPointBase.__new__","name":"__new__","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["_cls","name","value","group"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"importlib.metadata._EntryPointBase._NT","id":-1,"name":"_NT","namespace":"importlib.metadata._EntryPointBase.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},"builtins.str","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of _EntryPointBase","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"importlib.metadata._EntryPointBase._NT","id":-1,"name":"_NT","namespace":"importlib.metadata._EntryPointBase.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"importlib.metadata._EntryPointBase._NT","id":-1,"name":"_NT","namespace":"importlib.metadata._EntryPointBase.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_asdict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["_self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"importlib.metadata._EntryPointBase._asdict","name":"_asdict","original_first_arg":"_self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["_self"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"importlib.metadata._EntryPointBase._NT","id":-1,"name":"_NT","namespace":"importlib.metadata._EntryPointBase._asdict","upper_bound":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_asdict of _EntryPointBase","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"importlib.metadata._EntryPointBase._NT","id":-1,"name":"_NT","namespace":"importlib.metadata._EntryPointBase._asdict","upper_bound":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_field_defaults":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"importlib.metadata._EntryPointBase._field_defaults","name":"_field_defaults","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_field_types":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"importlib.metadata._EntryPointBase._field_types","name":"_field_types","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_fields":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"importlib.metadata._EntryPointBase._fields","name":"_fields","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_make":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["_cls","iterable"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated"],"fullname":"importlib.metadata._EntryPointBase._make","name":"_make","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["_cls","iterable"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"importlib.metadata._EntryPointBase._NT","id":-1,"name":"_NT","namespace":"importlib.metadata._EntryPointBase._make","upper_bound":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_make of _EntryPointBase","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"importlib.metadata._EntryPointBase._NT","id":-1,"name":"_NT","namespace":"importlib.metadata._EntryPointBase._make","upper_bound":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"importlib.metadata._EntryPointBase._NT","id":-1,"name":"_NT","namespace":"importlib.metadata._EntryPointBase._make","upper_bound":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_classmethod","is_ready"],"fullname":"importlib.metadata._EntryPointBase._make","name":"_make","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["_cls","iterable"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"importlib.metadata._EntryPointBase._NT","id":-1,"name":"_NT","namespace":"importlib.metadata._EntryPointBase._make","upper_bound":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_make of _EntryPointBase","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"importlib.metadata._EntryPointBase._NT","id":-1,"name":"_NT","namespace":"importlib.metadata._EntryPointBase._make","upper_bound":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"importlib.metadata._EntryPointBase._NT","id":-1,"name":"_NT","namespace":"importlib.metadata._EntryPointBase._make","upper_bound":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}}},"plugin_generated":true},"_replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5],"arg_names":["_self","name","value","group"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"importlib.metadata._EntryPointBase._replace","name":"_replace","original_first_arg":"_self","type":{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":["_self","name","value","group"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"importlib.metadata._EntryPointBase._NT","id":-1,"name":"_NT","namespace":"importlib.metadata._EntryPointBase._replace","upper_bound":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"builtins.str","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_replace of _EntryPointBase","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"importlib.metadata._EntryPointBase._NT","id":-1,"name":"_NT","namespace":"importlib.metadata._EntryPointBase._replace","upper_bound":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"importlib.metadata._EntryPointBase._NT","id":-1,"name":"_NT","namespace":"importlib.metadata._EntryPointBase._replace","upper_bound":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_source":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"importlib.metadata._EntryPointBase._source","name":"_source","setter_type":null,"type":"builtins.str"}},"group":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"importlib.metadata._EntryPointBase.group","name":"group","setter_type":null,"type":"builtins.str"}},"group-redefinition":{".class":"SymbolTableNode","cross_ref":"importlib.metadata._EntryPointBase.group","kind":"Mdef"},"name":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"importlib.metadata._EntryPointBase.name","name":"name","setter_type":null,"type":"builtins.str"}},"name-redefinition":{".class":"SymbolTableNode","cross_ref":"importlib.metadata._EntryPointBase.name","kind":"Mdef"},"value":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"importlib.metadata._EntryPointBase.value","name":"value","setter_type":null,"type":"builtins.str"}},"value-redefinition":{".class":"SymbolTableNode","cross_ref":"importlib.metadata._EntryPointBase.value","kind":"Mdef"}},"self_type":null,"slots":null,"tuple_type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_vars":[],"typeddict_type":null}},"_KT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"importlib.metadata._KT","name":"_KT","upper_bound":"builtins.object","values":[],"variance":0}},"_SimplePath":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"importlib.metadata._SimplePath","line":43,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":"pathlib.Path"}},"_T":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"importlib.metadata._T","name":"_T","upper_bound":"builtins.object","values":[],"variance":0}},"_VT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"importlib.metadata._VT","name":"_VT","upper_bound":"builtins.object","values":[],"variance":0}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"importlib.metadata.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"importlib.metadata.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"importlib.metadata.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"importlib.metadata.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"importlib.metadata.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"importlib.metadata.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"importlib.metadata.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"importlib.metadata.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_distribution_parent":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"importlib.metadata._distribution_parent","line":218,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":"builtins.object"}},"abc":{".class":"SymbolTableNode","cross_ref":"abc","kind":"Gdef","module_hidden":true,"module_public":false},"deprecated":{".class":"SymbolTableNode","cross_ref":"typing_extensions.deprecated","kind":"Gdef","module_hidden":true,"module_public":false},"dict_keys":{".class":"SymbolTableNode","cross_ref":"_collections_abc.dict_keys","kind":"Gdef","module_hidden":true,"module_public":false},"dict_values":{".class":"SymbolTableNode","cross_ref":"_collections_abc.dict_values","kind":"Gdef","module_hidden":true,"module_public":false},"disjoint_base":{".class":"SymbolTableNode","cross_ref":"typing_extensions.disjoint_base","kind":"Gdef","module_hidden":true,"module_public":false},"distribution":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["distribution_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"importlib.metadata.distribution","name":"distribution","original_first_arg":"distribution_name","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["distribution_name"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"distribution","ret_type":"importlib.metadata.Distribution","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"distributions":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"importlib.metadata.distributions","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3],"arg_names":["context"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"importlib.metadata.distributions","name":"distributions","original_first_arg":"context","type":{".class":"CallableType","arg_kinds":[3],"arg_names":["context"],"arg_types":["importlib.metadata.DistributionFinder.Context"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"distributions","ret_type":{".class":"Instance","args":["importlib.metadata.Distribution"],"extra_attrs":null,"type_ref":"typing.Iterable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"importlib.metadata.distributions","name":"distributions","setter_type":null,"type":{".class":"CallableType","arg_kinds":[3],"arg_names":["context"],"arg_types":["importlib.metadata.DistributionFinder.Context"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"distributions","ret_type":{".class":"Instance","args":["importlib.metadata.Distribution"],"extra_attrs":null,"type_ref":"typing.Iterable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,4],"arg_names":["context","name","path","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"importlib.metadata.distributions","name":"distributions","original_first_arg":"context","type":{".class":"CallableType","arg_kinds":[5,5,5,4],"arg_names":["context","name","path","kwargs"],"arg_types":[{".class":"NoneType"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"distributions","ret_type":{".class":"Instance","args":["importlib.metadata.Distribution"],"extra_attrs":null,"type_ref":"typing.Iterable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"importlib.metadata.distributions","name":"distributions","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,4],"arg_names":["context","name","path","kwargs"],"arg_types":[{".class":"NoneType"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"distributions","ret_type":{".class":"Instance","args":["importlib.metadata.Distribution"],"extra_attrs":null,"type_ref":"typing.Iterable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[3],"arg_names":["context"],"arg_types":["importlib.metadata.DistributionFinder.Context"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"distributions","ret_type":{".class":"Instance","args":["importlib.metadata.Distribution"],"extra_attrs":null,"type_ref":"typing.Iterable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[5,5,5,4],"arg_names":["context","name","path","kwargs"],"arg_types":[{".class":"NoneType"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"distributions","ret_type":{".class":"Instance","args":["importlib.metadata.Distribution"],"extra_attrs":null,"type_ref":"typing.Iterable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"entry_points":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"importlib.metadata.entry_points","name":"entry_points","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"entry_points","ret_type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"importlib.metadata.EntryPoint"}],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"files":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["distribution_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"importlib.metadata.files","name":"files","original_first_arg":"distribution_name","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["distribution_name"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"files","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["importlib.metadata.PackagePath"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"metadata":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["distribution_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"importlib.metadata.metadata","name":"metadata","original_first_arg":"distribution_name","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["distribution_name"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"metadata","ret_type":{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"email.message.Message"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false},"pathlib":{".class":"SymbolTableNode","cross_ref":"pathlib","kind":"Gdef","module_hidden":true,"module_public":false},"requires":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["distribution_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"importlib.metadata.requires","name":"requires","original_first_arg":"distribution_name","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["distribution_name"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"requires","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"sys":{".class":"SymbolTableNode","cross_ref":"sys","kind":"Gdef","module_hidden":true,"module_public":false},"types":{".class":"SymbolTableNode","cross_ref":"types","kind":"Gdef","module_hidden":true,"module_public":false},"version":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["distribution_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"importlib.metadata.version","name":"version","original_first_arg":"distribution_name","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["distribution_name"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"version","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/mypy/typeshed/stdlib/importlib/metadata/__init__.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/importlib/metadata/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/importlib/metadata/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..8c2f8a3bee0acc5d9bbd2f351841c28c5ace8556 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/importlib/metadata/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106713,"dep_lines":[7,8,9,1,2,3,4,5,6,10,12,13,14,1,1,1],"dep_prios":[5,5,5,10,5,10,10,5,5,5,5,5,5,5,30,30],"dependencies":["collections.abc","email.message","importlib.abc","abc","pathlib","sys","types","_collections_abc","_typeshed","os","re","typing","typing_extensions","builtins","_frozen_importlib","email"],"hash":"cfef57f1d5343139633a3ccf1a086852c7a83c56","id":"importlib.metadata","ignore_all":true,"interface_hash":"cc3c73df5c18e52aedab219c2a39daacf2e013b7","mtime":1764106509,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/mypy/typeshed/stdlib/importlib/metadata/__init__.pyi","plugin_data":null,"size":10488,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/importlib/resources/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/importlib/resources/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..4c49399cfb6f0511fda3cfdcba22b939f92a5d1f --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/importlib/resources/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"importlib.resources","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","AbstractContextManager":{".class":"SymbolTableNode","cross_ref":"contextlib.AbstractContextManager","kind":"Gdef","module_hidden":true,"module_public":false},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"BinaryIO":{".class":"SymbolTableNode","cross_ref":"typing.BinaryIO","kind":"Gdef","module_hidden":true,"module_public":false},"Iterator":{".class":"SymbolTableNode","cross_ref":"typing.Iterator","kind":"Gdef","module_hidden":true,"module_public":false},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"ModuleType":{".class":"SymbolTableNode","cross_ref":"types.ModuleType","kind":"Gdef","module_hidden":true,"module_public":false},"Package":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"importlib.resources.Package","line":18,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["builtins.str","types.ModuleType"],"uses_pep604_syntax":true}}},"Path":{".class":"SymbolTableNode","cross_ref":"pathlib.Path","kind":"Gdef","module_hidden":true,"module_public":false},"Resource":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"importlib.resources.Resource","line":40,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"os.PathLike"}],"uses_pep604_syntax":true}}},"TextIO":{".class":"SymbolTableNode","cross_ref":"typing.TextIO","kind":"Gdef","module_hidden":true,"module_public":false},"Traversable":{".class":"SymbolTableNode","cross_ref":"importlib.abc.Traversable","kind":"Gdef","module_hidden":true,"module_public":false},"TypeAlias":{".class":"SymbolTableNode","cross_ref":"typing_extensions.TypeAlias","kind":"Gdef","module_hidden":true,"module_public":false},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"importlib.resources.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"importlib.resources.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"importlib.resources.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"importlib.resources.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"importlib.resources.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"importlib.resources.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"importlib.resources.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"importlib.resources.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"as_file":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["path"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"importlib.resources.as_file","name":"as_file","original_first_arg":"path","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["path"],"arg_types":["importlib.abc.Traversable"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_file","ret_type":{".class":"Instance","args":["pathlib.Path",{".class":"LiteralType","fallback":"builtins.bool","value":false}],"extra_attrs":null,"type_ref":"contextlib.AbstractContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"contents":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["package"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"importlib.resources.contents","name":"contents","original_first_arg":"package","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["package"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"importlib.resources.Package"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"contents","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"files":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["package"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"importlib.resources.files","name":"files","original_first_arg":"package","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["package"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"importlib.resources.Package"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"files","ret_type":"importlib.abc.Traversable","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_resource":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["package","name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"importlib.resources.is_resource","name":"is_resource","original_first_arg":"package","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["package","name"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"importlib.resources.Package"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_resource","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"open_binary":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["package","resource"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"importlib.resources.open_binary","name":"open_binary","original_first_arg":"package","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["package","resource"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"importlib.resources.Package"},{".class":"TypeAliasType","args":[],"type_ref":"importlib.resources.Resource"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"open_binary","ret_type":"typing.BinaryIO","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"open_text":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["package","resource","encoding","errors"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"importlib.resources.open_text","name":"open_text","original_first_arg":"package","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["package","resource","encoding","errors"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"importlib.resources.Package"},{".class":"TypeAliasType","args":[],"type_ref":"importlib.resources.Resource"},"builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"open_text","ret_type":"typing.TextIO","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"os":{".class":"SymbolTableNode","cross_ref":"os","kind":"Gdef","module_hidden":true,"module_public":false},"path":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["package","resource"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"importlib.resources.path","name":"path","original_first_arg":"package","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["package","resource"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"importlib.resources.Package"},{".class":"TypeAliasType","args":[],"type_ref":"importlib.resources.Resource"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"path","ret_type":{".class":"Instance","args":["pathlib.Path",{".class":"LiteralType","fallback":"builtins.bool","value":false}],"extra_attrs":null,"type_ref":"contextlib.AbstractContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"read_binary":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["package","resource"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"importlib.resources.read_binary","name":"read_binary","original_first_arg":"package","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["package","resource"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"importlib.resources.Package"},{".class":"TypeAliasType","args":[],"type_ref":"importlib.resources.Resource"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"read_binary","ret_type":"builtins.bytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"read_text":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["package","resource","encoding","errors"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"importlib.resources.read_text","name":"read_text","original_first_arg":"package","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["package","resource","encoding","errors"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"importlib.resources.Package"},{".class":"TypeAliasType","args":[],"type_ref":"importlib.resources.Resource"},"builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"read_text","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"sys":{".class":"SymbolTableNode","cross_ref":"sys","kind":"Gdef","module_hidden":true,"module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/mypy/typeshed/stdlib/importlib/resources/__init__.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/importlib/resources/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/importlib/resources/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..6780c1955d07af6a185b672ac13cc24a77b5f592 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/importlib/resources/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106714,"dep_lines":[3,13,1,2,4,5,6,7,8,1,1,1,1],"dep_prios":[5,5,10,10,5,5,5,5,5,5,30,30,30],"dependencies":["collections.abc","importlib.abc","os","sys","contextlib","pathlib","types","typing","typing_extensions","builtins","_frozen_importlib","_typeshed","abc"],"hash":"180fd58c879a781095b50e2e2904fca62b1c9b71","id":"importlib.resources","ignore_all":true,"interface_hash":"fa6955538ea2d764c10e6fd97aa26b0aacc900f8","mtime":1764106509,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/mypy/typeshed/stdlib/importlib/resources/__init__.pyi","plugin_data":null,"size":2564,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/common/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/common/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..76158ced74baa275f7ae537170a707e6fe3f3d3a --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/common/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.common","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/common/__init__.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/common/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/common/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..5b82f2a3c487d55beed702cf023aafb03d6f0087 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/common/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106713,"dep_lines":[1,1,1,1],"dep_prios":[5,30,30,30],"dependencies":["builtins","_frozen_importlib","abc","typing"],"hash":"da39a3ee5e6b4b0d3255bfef95601890afd80709","id":"markdown_it.common","ignore_all":true,"interface_hash":"20ee40c2c8c2a0d8840b7007b713a478c7c1d7a8","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/common/__init__.py","plugin_data":null,"size":0,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/common/entities.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/common/entities.data.json new file mode 100644 index 0000000000000000000000000000000000000000..75371bc134fa7420c813995d21921a1803b51415 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/common/entities.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.common.entities","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.entities.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.entities.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.entities.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.entities.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.entities.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.entities.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"entities":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.common.entities.entities","name":"entities","setter_type":null,"type":{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"html":{".class":"SymbolTableNode","cross_ref":"html","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/common/entities.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/common/entities.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/common/entities.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..b68315e1528c9b0927f30c771f4a207b08af54be --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/common/entities.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106714,"dep_lines":[3,3,1,1,1,1,1],"dep_prios":[10,20,5,30,30,30,30],"dependencies":["html.entities","html","builtins","_collections_abc","_frozen_importlib","abc","typing"],"hash":"5cf9add9a0ef0eff2980024323a76d7c5cb4e55f","id":"markdown_it.common.entities","ignore_all":true,"interface_hash":"164a7def56dc90f05230db4e3330779340df6159","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/common/entities.py","plugin_data":null,"size":157,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/common/html_blocks.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/common/html_blocks.data.json new file mode 100644 index 0000000000000000000000000000000000000000..3362a31fe5f28a44a7145c82943b256eaa8fdd4b --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/common/html_blocks.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.common.html_blocks","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.html_blocks.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.html_blocks.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.html_blocks.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.html_blocks.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.html_blocks.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.html_blocks.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"block_names":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.common.html_blocks.block_names","name":"block_names","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/common/html_blocks.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/common/html_blocks.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/common/html_blocks.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..dc9803712876a53832ad92612d2ba8a7fa8e857c --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/common/html_blocks.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106713,"dep_lines":[1,1,1,1],"dep_prios":[5,30,30,30],"dependencies":["builtins","_frozen_importlib","abc","typing"],"hash":"96ce4874108c1ee45fdfb6c4ccf1747146ad4059","id":"markdown_it.common.html_blocks","ignore_all":true,"interface_hash":"addfce9c394d8982fd465fb12902394e446c4926","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/common/html_blocks.py","plugin_data":null,"size":986,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/common/html_re.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/common/html_re.data.json new file mode 100644 index 0000000000000000000000000000000000000000..673fa298c5f3856b9942b0cd8b4a04e98ead76f9 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/common/html_re.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.common.html_re","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","HTML_OPEN_CLOSE_TAG_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.common.html_re.HTML_OPEN_CLOSE_TAG_RE","name":"HTML_OPEN_CLOSE_TAG_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"HTML_OPEN_CLOSE_TAG_STR":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.common.html_re.HTML_OPEN_CLOSE_TAG_STR","name":"HTML_OPEN_CLOSE_TAG_STR","setter_type":null,"type":"builtins.str"}},"HTML_TAG_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.common.html_re.HTML_TAG_RE","name":"HTML_TAG_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.html_re.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.html_re.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.html_re.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.html_re.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.html_re.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.html_re.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"attr_name":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.common.html_re.attr_name","name":"attr_name","setter_type":null,"type":"builtins.str"}},"attr_value":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.common.html_re.attr_value","name":"attr_value","setter_type":null,"type":"builtins.str"}},"attribute":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.common.html_re.attribute","name":"attribute","setter_type":null,"type":"builtins.str"}},"cdata":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.common.html_re.cdata","name":"cdata","setter_type":null,"type":"builtins.str"}},"close_tag":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.common.html_re.close_tag","name":"close_tag","setter_type":null,"type":"builtins.str"}},"comment":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.common.html_re.comment","name":"comment","setter_type":null,"type":"builtins.str"}},"declaration":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.common.html_re.declaration","name":"declaration","setter_type":null,"type":"builtins.str"}},"double_quoted":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.common.html_re.double_quoted","name":"double_quoted","setter_type":null,"type":"builtins.str"}},"open_tag":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.common.html_re.open_tag","name":"open_tag","setter_type":null,"type":"builtins.str"}},"processing":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.common.html_re.processing","name":"processing","setter_type":null,"type":"builtins.str"}},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef"},"single_quoted":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.common.html_re.single_quoted","name":"single_quoted","setter_type":null,"type":"builtins.str"}},"unquoted":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.common.html_re.unquoted","name":"unquoted","setter_type":null,"type":"builtins.str"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/common/html_re.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/common/html_re.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/common/html_re.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..3cc9dcde05b91f960073447d3c147995760c080e --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/common/html_re.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106713,"dep_lines":[3,1,1,1,1,1],"dep_prios":[10,5,30,30,30,30],"dependencies":["re","builtins","_frozen_importlib","abc","enum","typing"],"hash":"6fe0c7116ef0d277de83602439843d6940bedce3","id":"markdown_it.common.html_re","ignore_all":true,"interface_hash":"2cb9c69e835ace6fa36399b8220e4312a418b3a0","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/common/html_re.py","plugin_data":null,"size":926,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/common/normalize_url.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/common/normalize_url.data.json new file mode 100644 index 0000000000000000000000000000000000000000..ac89962e8486dd006adbd9d94ab9f671b7edfbe0 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/common/normalize_url.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.common.normalize_url","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","BAD_PROTO_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.common.normalize_url.BAD_PROTO_RE","name":"BAD_PROTO_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"GOOD_DATA_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.common.normalize_url.GOOD_DATA_RE","name":"GOOD_DATA_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"RECODE_HOSTNAME_FOR":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.common.normalize_url.RECODE_HOSTNAME_FOR","name":"RECODE_HOSTNAME_FOR","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.normalize_url.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.normalize_url.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.normalize_url.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.normalize_url.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.normalize_url.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.normalize_url.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_punycode":{".class":"SymbolTableNode","cross_ref":"markdown_it._punycode","kind":"Gdef"},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"mdurl":{".class":"SymbolTableNode","cross_ref":"mdurl","kind":"Gdef"},"normalizeLink":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["url"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.common.normalize_url.normalizeLink","name":"normalizeLink","original_first_arg":"url","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["url"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"normalizeLink","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"normalizeLinkText":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["url"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.common.normalize_url.normalizeLinkText","name":"normalizeLinkText","original_first_arg":"url","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["url"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"normalizeLinkText","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"quote":{".class":"SymbolTableNode","cross_ref":"urllib.parse.quote","kind":"Gdef"},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef"},"suppress":{".class":"SymbolTableNode","cross_ref":"contextlib.suppress","kind":"Gdef"},"unquote":{".class":"SymbolTableNode","cross_ref":"urllib.parse.unquote","kind":"Gdef"},"urlparse":{".class":"SymbolTableNode","cross_ref":"urllib.parse.urlparse","kind":"Gdef"},"urlunparse":{".class":"SymbolTableNode","cross_ref":"urllib.parse.urlunparse","kind":"Gdef"},"validateLink":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["url","validator"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.common.normalize_url.validateLink","name":"validateLink","original_first_arg":"url","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["url","validator"],"arg_types":["builtins.str",{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validateLink","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/common/normalize_url.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/common/normalize_url.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/common/normalize_url.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..18a56fbd6ec63b28090e9602da3acdf63eaeb051 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/common/normalize_url.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[3,6,10,1,4,5,8,10,1,1,1,1,1],"dep_prios":[5,5,10,5,5,10,10,20,5,30,30,30,30],"dependencies":["collections.abc","urllib.parse","markdown_it._punycode","__future__","contextlib","re","mdurl","markdown_it","builtins","_frozen_importlib","abc","enum","typing"],"hash":"efeb60a8890c22778d680380822f4ac00fe9a5af","id":"markdown_it.common.normalize_url","ignore_all":true,"interface_hash":"e9ced81e84e6f057637005fb6f52f657f5eae86f","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/common/normalize_url.py","plugin_data":null,"size":2568,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/common/utils.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/common/utils.data.json new file mode 100644 index 0000000000000000000000000000000000000000..727f376ab6aec8d04225532193f8f3536fcdb7be --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/common/utils.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.common.utils","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","DIGITAL_ENTITY_BASE10_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.common.utils.DIGITAL_ENTITY_BASE10_RE","name":"DIGITAL_ENTITY_BASE10_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"DIGITAL_ENTITY_BASE16_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.common.utils.DIGITAL_ENTITY_BASE16_RE","name":"DIGITAL_ENTITY_BASE16_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"ESCAPABLE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.common.utils.ESCAPABLE","name":"ESCAPABLE","setter_type":null,"type":"builtins.str"}},"ESCAPE_CHAR":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.common.utils.ESCAPE_CHAR","name":"ESCAPE_CHAR","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"LINK_CLOSE_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.common.utils.LINK_CLOSE_RE","name":"LINK_CLOSE_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"LINK_OPEN_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.common.utils.LINK_OPEN_RE","name":"LINK_OPEN_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"MD_ASCII_PUNCT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.common.utils.MD_ASCII_PUNCT","name":"MD_ASCII_PUNCT","setter_type":null,"type":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.set"}}},"MD_WHITESPACE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.common.utils.MD_WHITESPACE","name":"MD_WHITESPACE","setter_type":null,"type":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.set"}}},"Match":{".class":"SymbolTableNode","cross_ref":"re.Match","kind":"Gdef"},"REGEXP_ESCAPE_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.common.utils.REGEXP_ESCAPE_RE","name":"REGEXP_ESCAPE_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef"},"UNESCAPE_ALL_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.common.utils.UNESCAPE_ALL_RE","name":"UNESCAPE_ALL_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"_ItemTV":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"markdown_it.common.utils._ItemTV","name":"_ItemTV","upper_bound":"builtins.object","values":[],"variance":0}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.utils.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.utils.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.utils.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.utils.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.utils.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.common.utils.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"arrayReplaceAt":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["src","pos","newElements"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.common.utils.arrayReplaceAt","name":"arrayReplaceAt","original_first_arg":"src","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["src","pos","newElements"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"markdown_it.common.utils._ItemTV","id":-1,"name":"_ItemTV","namespace":"markdown_it.common.utils.arrayReplaceAt","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.list"},"builtins.int",{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"markdown_it.common.utils._ItemTV","id":-1,"name":"_ItemTV","namespace":"markdown_it.common.utils.arrayReplaceAt","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arrayReplaceAt","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"markdown_it.common.utils._ItemTV","id":-1,"name":"_ItemTV","namespace":"markdown_it.common.utils.arrayReplaceAt","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"markdown_it.common.utils._ItemTV","id":-1,"name":"_ItemTV","namespace":"markdown_it.common.utils.arrayReplaceAt","upper_bound":"builtins.object","values":[],"variance":0}]}}},"charCodeAt":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["src","pos"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.common.utils.charCodeAt","name":"charCodeAt","original_first_arg":"src","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["src","pos"],"arg_types":["builtins.str","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"charCodeAt","ret_type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"charStrAt":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["src","pos"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.common.utils.charStrAt","name":"charStrAt","original_first_arg":"src","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["src","pos"],"arg_types":["builtins.str","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"charStrAt","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"entities":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.entities.entities","kind":"Gdef"},"escapeHtml":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["raw"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.common.utils.escapeHtml","name":"escapeHtml","original_first_arg":"raw","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["raw"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"escapeHtml","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"escapeRE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["string"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.common.utils.escapeRE","name":"escapeRE","original_first_arg":"string","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["string"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"escapeRE","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"fromCodePoint":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["c"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.common.utils.fromCodePoint","name":"fromCodePoint","original_first_arg":"c","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["c"],"arg_types":["builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromCodePoint","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isLinkClose":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["string"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.common.utils.isLinkClose","name":"isLinkClose","original_first_arg":"string","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["string"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isLinkClose","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isLinkOpen":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["string"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.common.utils.isLinkOpen","name":"isLinkOpen","original_first_arg":"string","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["string"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isLinkOpen","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isMdAsciiPunct":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["ch"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.common.utils.isMdAsciiPunct","name":"isMdAsciiPunct","original_first_arg":"ch","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["ch"],"arg_types":["builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isMdAsciiPunct","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isPunctChar":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["ch"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.common.utils.isPunctChar","name":"isPunctChar","original_first_arg":"ch","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["ch"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isPunctChar","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isSpace":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["code"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.common.utils.isSpace","name":"isSpace","original_first_arg":"code","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["code"],"arg_types":[{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isSpace","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isStrSpace":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["ch"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.common.utils.isStrSpace","name":"isStrSpace","original_first_arg":"ch","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["ch"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isStrSpace","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isValidEntityCode":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["c"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.common.utils.isValidEntityCode","name":"isValidEntityCode","original_first_arg":"c","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["c"],"arg_types":["builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isValidEntityCode","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isWhiteSpace":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["code"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.common.utils.isWhiteSpace","name":"isWhiteSpace","original_first_arg":"code","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["code"],"arg_types":["builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isWhiteSpace","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"normalizeReference":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["string"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.common.utils.normalizeReference","name":"normalizeReference","original_first_arg":"string","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["string"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"normalizeReference","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef"},"replaceEntityPattern":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["match","name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.common.utils.replaceEntityPattern","name":"replaceEntityPattern","original_first_arg":"match","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["match","name"],"arg_types":["builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replaceEntityPattern","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"stripEscape":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["string"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.common.utils.stripEscape","name":"stripEscape","original_first_arg":"string","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["string"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"stripEscape","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"unescapeAll":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["string"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.common.utils.unescapeAll","name":"unescapeAll","original_first_arg":"string","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["string"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unescapeAll","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"unicodedata":{".class":"SymbolTableNode","cross_ref":"unicodedata","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/common/utils.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/common/utils.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/common/utils.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..ccb257b59557169f68d14857bca28c71cf20f0dd --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/common/utils.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106714,"dep_lines":[10,3,5,7,8,1,1,1,1],"dep_prios":[5,5,5,5,10,5,30,30,30],"dependencies":["markdown_it.common.entities","__future__","re","typing","unicodedata","builtins","_frozen_importlib","abc","enum"],"hash":"ce81ce42285d11280eb199e41fd88b48d554a333","id":"markdown_it.common.utils","ignore_all":true,"interface_hash":"6f36039d8862ada2acfe0d8d97cffced395b38a9","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/common/utils.py","plugin_data":null,"size":8734,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/helpers/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/helpers/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..dfcb85b089bdc14783dcb33452edc6ec86908e8e --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/helpers/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.helpers","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.helpers.__all__","name":"__all__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.helpers.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.helpers.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.helpers.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.helpers.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.helpers.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.helpers.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.helpers.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"parseLinkDestination":{".class":"SymbolTableNode","cross_ref":"markdown_it.helpers.parse_link_destination.parseLinkDestination","kind":"Gdef"},"parseLinkLabel":{".class":"SymbolTableNode","cross_ref":"markdown_it.helpers.parse_link_label.parseLinkLabel","kind":"Gdef"},"parseLinkTitle":{".class":"SymbolTableNode","cross_ref":"markdown_it.helpers.parse_link_title.parseLinkTitle","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/helpers/__init__.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/helpers/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/helpers/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..374d65a74f8c8a6e4b376ff33cf27af09d2456e9 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/helpers/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[4,5,6,1,1,1,1],"dep_prios":[5,5,5,5,30,30,30],"dependencies":["markdown_it.helpers.parse_link_destination","markdown_it.helpers.parse_link_label","markdown_it.helpers.parse_link_title","builtins","_frozen_importlib","abc","typing"],"hash":"308cbd32c3ea7b98a54ba095aea124b2edda160f","id":"markdown_it.helpers","ignore_all":true,"interface_hash":"f0bcc0d1fd0068c69d02a717272a5d083a2b753b","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/helpers/__init__.py","plugin_data":null,"size":253,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/helpers/parse_link_destination.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/helpers/parse_link_destination.data.json new file mode 100644 index 0000000000000000000000000000000000000000..4307ba41cb039f9c6a836acb8fce67d1c9b3b976 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/helpers/parse_link_destination.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.helpers.parse_link_destination","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","_Result":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"markdown_it.helpers.parse_link_destination._Result","name":"_Result","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"markdown_it.helpers.parse_link_destination._Result","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"markdown_it.helpers.parse_link_destination","mro":["markdown_it.helpers.parse_link_destination._Result","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"markdown_it.helpers.parse_link_destination._Result.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["markdown_it.helpers.parse_link_destination._Result"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of _Result","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"markdown_it.helpers.parse_link_destination._Result.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"ok":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"markdown_it.helpers.parse_link_destination._Result.ok","name":"ok","setter_type":null,"type":"builtins.bool"}},"pos":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"markdown_it.helpers.parse_link_destination._Result.pos","name":"pos","setter_type":null,"type":"builtins.int"}},"str":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"markdown_it.helpers.parse_link_destination._Result.str","name":"str","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"markdown_it.helpers.parse_link_destination._Result.Self","id":0,"name":"Self","namespace":"","upper_bound":"markdown_it.helpers.parse_link_destination._Result","values":[],"variance":0},"slots":["ok","pos","str"],"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.helpers.parse_link_destination.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.helpers.parse_link_destination.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.helpers.parse_link_destination.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.helpers.parse_link_destination.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.helpers.parse_link_destination.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.helpers.parse_link_destination.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"charCodeAt":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.utils.charCodeAt","kind":"Gdef"},"parseLinkDestination":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["string","pos","maximum"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.helpers.parse_link_destination.parseLinkDestination","name":"parseLinkDestination","original_first_arg":"string","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["string","pos","maximum"],"arg_types":["builtins.str","builtins.int","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parseLinkDestination","ret_type":"markdown_it.helpers.parse_link_destination._Result","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"unescapeAll":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.utils.unescapeAll","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/helpers/parse_link_destination.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/helpers/parse_link_destination.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/helpers/parse_link_destination.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..ea726a04df3933e19dd3eb6bb98f46dff17b069a --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/helpers/parse_link_destination.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106714,"dep_lines":[5,1,1,1,1],"dep_prios":[5,5,30,30,30],"dependencies":["markdown_it.common.utils","builtins","_frozen_importlib","abc","typing"],"hash":"bf8975fcd713de42ade405e74311319a76230065","id":"markdown_it.helpers.parse_link_destination","ignore_all":true,"interface_hash":"1edf97789c1479510e9a36e4d63a5a73ad4da08f","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/helpers/parse_link_destination.py","plugin_data":null,"size":1906,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/helpers/parse_link_label.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/helpers/parse_link_label.data.json new file mode 100644 index 0000000000000000000000000000000000000000..ba18e092796f8bbc9a106535bdf2de9f6116ab2c --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/helpers/parse_link_label.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.helpers.parse_link_label","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","StateInline":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_inline.state_inline.StateInline","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.helpers.parse_link_label.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.helpers.parse_link_label.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.helpers.parse_link_label.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.helpers.parse_link_label.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.helpers.parse_link_label.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.helpers.parse_link_label.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"parseLinkLabel":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["state","start","disableNested"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.helpers.parse_link_label.parseLinkLabel","name":"parseLinkLabel","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["state","start","disableNested"],"arg_types":["markdown_it.rules_inline.state_inline.StateInline","builtins.int","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parseLinkLabel","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/helpers/parse_link_label.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/helpers/parse_link_label.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/helpers/parse_link_label.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..995782f27f584f59aa4c618273b2eecf55918aa2 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/helpers/parse_link_label.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[9,1,1,1,1,1,1],"dep_prios":[5,5,30,30,30,30,30],"dependencies":["markdown_it.rules_inline","builtins","_frozen_importlib","abc","markdown_it.ruler","markdown_it.rules_inline.state_inline","typing"],"hash":"e2deb92a698ebd9fa0162fb3e0a7ae8ff71f6d4e","id":"markdown_it.helpers.parse_link_label","ignore_all":true,"interface_hash":"b87f17fca8db14ecc420d94284dee6579c6e95b2","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/helpers/parse_link_label.py","plugin_data":null,"size":1037,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/helpers/parse_link_title.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/helpers/parse_link_title.data.json new file mode 100644 index 0000000000000000000000000000000000000000..88399f46ad42db635e5094a830ea1953bc08a06b --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/helpers/parse_link_title.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.helpers.parse_link_title","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","_State":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"markdown_it.helpers.parse_link_title._State","name":"_State","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"markdown_it.helpers.parse_link_title._State","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"markdown_it.helpers.parse_link_title","mro":["markdown_it.helpers.parse_link_title._State","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"markdown_it.helpers.parse_link_title._State.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["markdown_it.helpers.parse_link_title._State"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of _State","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"markdown_it.helpers.parse_link_title._State.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"__str__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"markdown_it.helpers.parse_link_title._State.__str__","name":"__str__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["markdown_it.helpers.parse_link_title._State"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__str__ of _State","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"can_continue":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"markdown_it.helpers.parse_link_title._State.can_continue","name":"can_continue","setter_type":null,"type":"builtins.bool"}},"marker":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"markdown_it.helpers.parse_link_title._State.marker","name":"marker","setter_type":null,"type":"builtins.int"}},"ok":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"markdown_it.helpers.parse_link_title._State.ok","name":"ok","setter_type":null,"type":"builtins.bool"}},"pos":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"markdown_it.helpers.parse_link_title._State.pos","name":"pos","setter_type":null,"type":"builtins.int"}},"str":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"markdown_it.helpers.parse_link_title._State.str","name":"str","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"markdown_it.helpers.parse_link_title._State.Self","id":0,"name":"Self","namespace":"","upper_bound":"markdown_it.helpers.parse_link_title._State","values":[],"variance":0},"slots":["can_continue","marker","ok","pos","str"],"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.helpers.parse_link_title.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.helpers.parse_link_title.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.helpers.parse_link_title.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.helpers.parse_link_title.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.helpers.parse_link_title.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.helpers.parse_link_title.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"charCodeAt":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.utils.charCodeAt","kind":"Gdef"},"parseLinkTitle":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["string","start","maximum","prev_state"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.helpers.parse_link_title.parseLinkTitle","name":"parseLinkTitle","original_first_arg":"string","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["string","start","maximum","prev_state"],"arg_types":["builtins.str","builtins.int","builtins.int",{".class":"UnionType","items":["markdown_it.helpers.parse_link_title._State",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parseLinkTitle","ret_type":"markdown_it.helpers.parse_link_title._State","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"unescapeAll":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.utils.unescapeAll","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/helpers/parse_link_title.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/helpers/parse_link_title.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/helpers/parse_link_title.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..b1a8878e9e823e847728ef7da97e3f343c823a78 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/helpers/parse_link_title.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106714,"dep_lines":[3,1,1,1,1],"dep_prios":[5,5,30,30,30],"dependencies":["markdown_it.common.utils","builtins","_frozen_importlib","abc","typing"],"hash":"8dc0e7d401333476980ba358b67ad45e3c7e7a0d","id":"markdown_it.helpers.parse_link_title","ignore_all":true,"interface_hash":"b96ebea53b37d5b3c342929b5af00d3af0f1200c","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/helpers/parse_link_title.py","plugin_data":null,"size":2273,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/presets/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/presets/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..4d12262564e34e162d6574f854c3796d85232706 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/presets/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.presets","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","PresetType":{".class":"SymbolTableNode","cross_ref":"markdown_it.utils.PresetType","kind":"Gdef","module_public":false},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.presets.__all__","name":"__all__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.presets.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.presets.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.presets.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.presets.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.presets.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.presets.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.presets.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"commonmark":{".class":"SymbolTableNode","cross_ref":"markdown_it.presets.commonmark","kind":"Gdef"},"default":{".class":"SymbolTableNode","cross_ref":"markdown_it.presets.default","kind":"Gdef"},"gfm_like":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"markdown_it.presets.gfm_like","name":"gfm_like","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"markdown_it.presets.gfm_like","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"markdown_it.presets","mro":["markdown_it.presets.gfm_like","builtins.object"],"names":{".class":"SymbolTable","make":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"markdown_it.presets.gfm_like.make","name":"make","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"make of gfm_like","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"markdown_it.utils.PresetType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_staticmethod","is_ready","is_inferred"],"fullname":"markdown_it.presets.gfm_like.make","name":"make","setter_type":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"make of gfm_like","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"markdown_it.utils.PresetType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"markdown_it.presets.gfm_like.Self","id":0,"name":"Self","namespace":"","upper_bound":"markdown_it.presets.gfm_like","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"js_default":{".class":"SymbolTableNode","cross_ref":"markdown_it.presets.default","kind":"Gdef"},"zero":{".class":"SymbolTableNode","cross_ref":"markdown_it.presets.zero","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/presets/__init__.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/presets/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/presets/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..7ee8254f7dba684ab277be8fdf1cf0359028849e --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/presets/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106714,"dep_lines":[4,4,4,3,1,1,1,1,1],"dep_prios":[10,10,10,5,5,30,30,30,30],"dependencies":["markdown_it.presets.commonmark","markdown_it.presets.default","markdown_it.presets.zero","markdown_it.utils","builtins","_frozen_importlib","abc","types","typing"],"hash":"1dbbb1e9e452e4f56d4234ed84a02d44d50e3a50","id":"markdown_it.presets","ignore_all":true,"interface_hash":"ef39772f1324ded0b02a7dc16301f177da7d7706","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/presets/__init__.py","plugin_data":null,"size":970,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/presets/commonmark.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/presets/commonmark.data.json new file mode 100644 index 0000000000000000000000000000000000000000..61e2f7ad4bc52dcb7a9706f41ed9d0ce330487d8 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/presets/commonmark.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.presets.commonmark","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","PresetType":{".class":"SymbolTableNode","cross_ref":"markdown_it.utils.PresetType","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.presets.commonmark.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.presets.commonmark.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.presets.commonmark.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.presets.commonmark.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.presets.commonmark.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.presets.commonmark.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"make":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.presets.commonmark.make","name":"make","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"make","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"markdown_it.utils.PresetType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/presets/commonmark.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/presets/commonmark.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/presets/commonmark.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..bb89d7748de20ef6030dbbbb10be914da9dd7e70 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/presets/commonmark.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106714,"dep_lines":[10,1,1,1,1],"dep_prios":[5,5,30,30,30],"dependencies":["markdown_it.utils","builtins","_frozen_importlib","abc","typing"],"hash":"bfdbe40b176a231c6ce2b837746848ca3e7a4a48","id":"markdown_it.presets.commonmark","ignore_all":true,"interface_hash":"bc05192ab5444de4421a563c3c021ca211dc586b","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/presets/commonmark.py","plugin_data":null,"size":2869,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/presets/default.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/presets/default.data.json new file mode 100644 index 0000000000000000000000000000000000000000..79d278f102d54a146887de60eaa2ac4eb8486ef2 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/presets/default.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.presets.default","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","PresetType":{".class":"SymbolTableNode","cross_ref":"markdown_it.utils.PresetType","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.presets.default.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.presets.default.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.presets.default.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.presets.default.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.presets.default.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.presets.default.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"make":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.presets.default.make","name":"make","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"make","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"markdown_it.utils.PresetType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/presets/default.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/presets/default.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/presets/default.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..3438258600fa5a312f7a551ca040762daf4038e2 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/presets/default.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106714,"dep_lines":[3,1,1,1,1],"dep_prios":[5,5,30,30,30],"dependencies":["markdown_it.utils","builtins","_frozen_importlib","abc","typing"],"hash":"e7964f9ed67786d110d649d439af1b97730c0e6f","id":"markdown_it.presets.default","ignore_all":true,"interface_hash":"6f7f66695bf289f35193a0a099b955c8cfd2d716","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/presets/default.py","plugin_data":null,"size":1811,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/presets/zero.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/presets/zero.data.json new file mode 100644 index 0000000000000000000000000000000000000000..05535deaf65e6d51e3ea4c80ff308c1a459b0ffa --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/presets/zero.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.presets.zero","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","PresetType":{".class":"SymbolTableNode","cross_ref":"markdown_it.utils.PresetType","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.presets.zero.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.presets.zero.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.presets.zero.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.presets.zero.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.presets.zero.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.presets.zero.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"make":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.presets.zero.make","name":"make","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"make","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"markdown_it.utils.PresetType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/presets/zero.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/presets/zero.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/presets/zero.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..556aa4521b2601560227f8bfeef99afeb44da6f3 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/presets/zero.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106714,"dep_lines":[6,1,1,1,1],"dep_prios":[5,5,30,30,30],"dependencies":["markdown_it.utils","builtins","_frozen_importlib","abc","typing"],"hash":"c84a35ca41297d2b25513dca27075558c5b847bc","id":"markdown_it.presets.zero","ignore_all":true,"interface_hash":"9e385c283e3ea6b50581105fa6d33688a2652d01","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/presets/zero.py","plugin_data":null,"size":2113,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..f7cb10d3f35efed132af311e22953deacd1141ff --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_block","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","StateBlock":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_block.state_block.StateBlock","kind":"Gdef"},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_block.__all__","name":"__all__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"blockquote":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_block.blockquote.blockquote","kind":"Gdef"},"code":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_block.code.code","kind":"Gdef"},"fence":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_block.fence.fence","kind":"Gdef"},"heading":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_block.heading.heading","kind":"Gdef"},"hr":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_block.hr.hr","kind":"Gdef"},"html_block":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_block.html_block.html_block","kind":"Gdef"},"lheading":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_block.lheading.lheading","kind":"Gdef"},"list_block":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_block.list.list_block","kind":"Gdef"},"paragraph":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_block.paragraph.paragraph","kind":"Gdef"},"reference":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_block.reference.reference","kind":"Gdef"},"table":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_block.table.table","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_block/__init__.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..898e2ce7924b382cd21d82d435ebc254f5bc4287 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[16,17,18,19,20,21,22,23,24,25,26,27,1,1,1,1],"dep_prios":[5,5,5,5,5,5,5,5,5,5,5,5,5,30,30,30],"dependencies":["markdown_it.rules_block.blockquote","markdown_it.rules_block.code","markdown_it.rules_block.fence","markdown_it.rules_block.heading","markdown_it.rules_block.hr","markdown_it.rules_block.html_block","markdown_it.rules_block.lheading","markdown_it.rules_block.list","markdown_it.rules_block.paragraph","markdown_it.rules_block.reference","markdown_it.rules_block.state_block","markdown_it.rules_block.table","builtins","_frozen_importlib","abc","typing"],"hash":"05d747e9f2b305057c15d8e477f27e2f53c9976c","id":"markdown_it.rules_block","ignore_all":true,"interface_hash":"a4dcabdb39475051d56e709b876371b8d4d7f5bd","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_block/__init__.py","plugin_data":null,"size":553,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/blockquote.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/blockquote.data.json new file mode 100644 index 0000000000000000000000000000000000000000..b31e84a14d372d56e84f5a53489db332f976dccf --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/blockquote.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_block.blockquote","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","LOGGER":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_block.blockquote.LOGGER","name":"LOGGER","setter_type":null,"type":"logging.Logger"}},"StateBlock":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_block.state_block.StateBlock","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.blockquote.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.blockquote.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.blockquote.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.blockquote.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.blockquote.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.blockquote.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"blockquote":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["state","startLine","endLine","silent"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_block.blockquote.blockquote","name":"blockquote","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["state","startLine","endLine","silent"],"arg_types":["markdown_it.rules_block.state_block.StateBlock","builtins.int","builtins.int","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"blockquote","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isStrSpace":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.utils.isStrSpace","kind":"Gdef"},"logging":{".class":"SymbolTableNode","cross_ref":"logging","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_block/blockquote.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/blockquote.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/blockquote.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..1765a1c17ccfccafbd86aca2fb3b4197d82ce9d2 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/blockquote.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[6,7,2,4,1,1,1,1,1],"dep_prios":[5,5,5,10,5,30,30,30,30],"dependencies":["markdown_it.common.utils","markdown_it.rules_block.state_block","__future__","logging","builtins","_frozen_importlib","abc","markdown_it.ruler","typing"],"hash":"499bcb0d236b22c1be06994c3d7c7687662eaad9","id":"markdown_it.rules_block.blockquote","ignore_all":true,"interface_hash":"649b390044c6eb4a3ad7dbcaf91ef4ce4266d032","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_block/blockquote.py","plugin_data":null,"size":8887,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/code.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/code.data.json new file mode 100644 index 0000000000000000000000000000000000000000..a2caf8438f156c46b50933348328ae919341efe3 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/code.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_block.code","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","LOGGER":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_block.code.LOGGER","name":"LOGGER","setter_type":null,"type":"logging.Logger"}},"StateBlock":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_block.state_block.StateBlock","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.code.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.code.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.code.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.code.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.code.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.code.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"code":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["state","startLine","endLine","silent"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_block.code.code","name":"code","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["state","startLine","endLine","silent"],"arg_types":["markdown_it.rules_block.state_block.StateBlock","builtins.int","builtins.int","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"code","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"logging":{".class":"SymbolTableNode","cross_ref":"logging","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_block/code.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/code.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/code.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..c7b96fa61fb6c13b22b093233e0f8cb1387209c1 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/code.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[5,3,1,1,1,1,1],"dep_prios":[5,10,5,30,30,30,30],"dependencies":["markdown_it.rules_block.state_block","logging","builtins","_frozen_importlib","abc","markdown_it.ruler","typing"],"hash":"9a6b0c1cb2f07e6b1830706231968b8543ed7539","id":"markdown_it.rules_block.code","ignore_all":true,"interface_hash":"7528481aa01253a8a1d214822f9aac4300f35d65","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_block/code.py","plugin_data":null,"size":860,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/fence.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/fence.data.json new file mode 100644 index 0000000000000000000000000000000000000000..d458d21eb3294525b58dbb8bcda1d4d43b3e853d --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/fence.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_block.fence","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","LOGGER":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_block.fence.LOGGER","name":"LOGGER","setter_type":null,"type":"logging.Logger"}},"StateBlock":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_block.state_block.StateBlock","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.fence.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.fence.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.fence.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.fence.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.fence.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.fence.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"fence":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["state","startLine","endLine","silent"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_block.fence.fence","name":"fence","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["state","startLine","endLine","silent"],"arg_types":["markdown_it.rules_block.state_block.StateBlock","builtins.int","builtins.int","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fence","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"logging":{".class":"SymbolTableNode","cross_ref":"logging","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_block/fence.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/fence.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/fence.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..a73814530fcd55179a19d90049f2033ebe371c03 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/fence.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[4,2,1,1,1,1,1],"dep_prios":[5,10,5,30,30,30,30],"dependencies":["markdown_it.rules_block.state_block","logging","builtins","_frozen_importlib","abc","markdown_it.ruler","typing"],"hash":"7a144b314f4b906cde625c9a4a9b42eb94b808d2","id":"markdown_it.rules_block.fence","ignore_all":true,"interface_hash":"72afb3a2d5244f11edae6c68abc9b5764ac76e43","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_block/fence.py","plugin_data":null,"size":2537,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/heading.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/heading.data.json new file mode 100644 index 0000000000000000000000000000000000000000..75fd146b190ec71a787f177e19558333937f55a0 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/heading.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_block.heading","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","LOGGER":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_block.heading.LOGGER","name":"LOGGER","setter_type":null,"type":"logging.Logger"}},"StateBlock":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_block.state_block.StateBlock","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.heading.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.heading.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.heading.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.heading.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.heading.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.heading.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"heading":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["state","startLine","endLine","silent"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_block.heading.heading","name":"heading","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["state","startLine","endLine","silent"],"arg_types":["markdown_it.rules_block.state_block.StateBlock","builtins.int","builtins.int","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"heading","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isStrSpace":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.utils.isStrSpace","kind":"Gdef"},"logging":{".class":"SymbolTableNode","cross_ref":"logging","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_block/heading.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/heading.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/heading.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..a9c75b4b25619b613bfcc821dbdcbdc6ce7723bb --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/heading.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[7,8,3,5,1,1,1,1,1],"dep_prios":[5,5,5,10,5,30,30,30,30],"dependencies":["markdown_it.common.utils","markdown_it.rules_block.state_block","__future__","logging","builtins","_frozen_importlib","abc","markdown_it.ruler","typing"],"hash":"22949080c38008fa17f9f16f8c9043a79f89c7e8","id":"markdown_it.rules_block.heading","ignore_all":true,"interface_hash":"4fc5305552b2eba67906941a1b748e38d848ec9e","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_block/heading.py","plugin_data":null,"size":1745,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/hr.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/hr.data.json new file mode 100644 index 0000000000000000000000000000000000000000..7ad094bba2626849439aa31a5ee80210b69f4345 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/hr.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_block.hr","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","LOGGER":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_block.hr.LOGGER","name":"LOGGER","setter_type":null,"type":"logging.Logger"}},"StateBlock":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_block.state_block.StateBlock","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.hr.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.hr.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.hr.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.hr.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.hr.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.hr.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"hr":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["state","startLine","endLine","silent"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_block.hr.hr","name":"hr","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["state","startLine","endLine","silent"],"arg_types":["markdown_it.rules_block.state_block.StateBlock","builtins.int","builtins.int","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hr","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isStrSpace":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.utils.isStrSpace","kind":"Gdef"},"logging":{".class":"SymbolTableNode","cross_ref":"logging","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_block/hr.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/hr.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/hr.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..24b98a597e933e09c495262657a77ae89d738712 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/hr.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[8,9,6,1,1,1,1,1],"dep_prios":[5,5,10,5,30,30,30,30],"dependencies":["markdown_it.common.utils","markdown_it.rules_block.state_block","logging","builtins","_frozen_importlib","abc","markdown_it.ruler","typing"],"hash":"1e3db64bae04ff715e172f8d129316c67627cb9b","id":"markdown_it.rules_block.hr","ignore_all":true,"interface_hash":"25e9bc871d55ce7ac592ae609ceebd5a22c1a02f","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_block/hr.py","plugin_data":null,"size":1227,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/html_block.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/html_block.data.json new file mode 100644 index 0000000000000000000000000000000000000000..3bdcfd3164a4214716f807012eee1b666e0a7eb6 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/html_block.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_block.html_block","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","HTML_OPEN_CLOSE_TAG_STR":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.html_re.HTML_OPEN_CLOSE_TAG_STR","kind":"Gdef"},"HTML_SEQUENCES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"markdown_it.rules_block.html_block.HTML_SEQUENCES","name":"HTML_SEQUENCES","setter_type":null,"type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"},"builtins.bool"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"builtins.list"}}},"LOGGER":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_block.html_block.LOGGER","name":"LOGGER","setter_type":null,"type":"logging.Logger"}},"StateBlock":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_block.state_block.StateBlock","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.html_block.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.html_block.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.html_block.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.html_block.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.html_block.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.html_block.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"block_names":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.html_blocks.block_names","kind":"Gdef"},"html_block":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["state","startLine","endLine","silent"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_block.html_block.html_block","name":"html_block","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["state","startLine","endLine","silent"],"arg_types":["markdown_it.rules_block.state_block.StateBlock","builtins.int","builtins.int","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"html_block","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"logging":{".class":"SymbolTableNode","cross_ref":"logging","kind":"Gdef"},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_block/html_block.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/html_block.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/html_block.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..bb7bcce15055635d9bfa11c9ef4c83a8787160a2 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/html_block.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[7,8,9,2,4,5,1,1,1,1,1,1],"dep_prios":[5,5,5,5,10,10,5,30,30,30,30,30],"dependencies":["markdown_it.common.html_blocks","markdown_it.common.html_re","markdown_it.rules_block.state_block","__future__","logging","re","builtins","_frozen_importlib","abc","enum","markdown_it.ruler","typing"],"hash":"82262d801dae5a9308c9ce3874fc815570918ef5","id":"markdown_it.rules_block.html_block","ignore_all":true,"interface_hash":"86cd93b1194549c9aa144e9a8b3057446225d57d","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_block/html_block.py","plugin_data":null,"size":2721,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/lheading.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/lheading.data.json new file mode 100644 index 0000000000000000000000000000000000000000..d2056c030847fc00c8284617b11a025d66a7254d --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/lheading.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_block.lheading","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","LOGGER":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_block.lheading.LOGGER","name":"LOGGER","setter_type":null,"type":"logging.Logger"}},"StateBlock":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_block.state_block.StateBlock","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.lheading.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.lheading.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.lheading.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.lheading.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.lheading.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.lheading.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"lheading":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["state","startLine","endLine","silent"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_block.lheading.lheading","name":"lheading","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["state","startLine","endLine","silent"],"arg_types":["markdown_it.rules_block.state_block.StateBlock","builtins.int","builtins.int","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lheading","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"logging":{".class":"SymbolTableNode","cross_ref":"logging","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_block/lheading.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/lheading.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/lheading.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..2e30564a64eae95ef1df7c77bcc95c9642d73a11 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/lheading.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[4,2,1,1,1,1,1],"dep_prios":[5,10,5,30,30,30,30],"dependencies":["markdown_it.rules_block.state_block","logging","builtins","_frozen_importlib","abc","markdown_it.ruler","typing"],"hash":"dfacff367364ecbd248dc9b8ca5a6cbb3871b0c4","id":"markdown_it.rules_block.lheading","ignore_all":true,"interface_hash":"17d1bf4e5e3acbc3a300d3fdb7cc44005dd455d1","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_block/lheading.py","plugin_data":null,"size":2625,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/list.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/list.data.json new file mode 100644 index 0000000000000000000000000000000000000000..6e516e6cb94e5e4daf836ab7ed7b30862eb806a4 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/list.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_block.list","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","LOGGER":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_block.list.LOGGER","name":"LOGGER","setter_type":null,"type":"logging.Logger"}},"StateBlock":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_block.state_block.StateBlock","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.list.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.list.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.list.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.list.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.list.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.list.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"isStrSpace":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.utils.isStrSpace","kind":"Gdef"},"list_block":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["state","startLine","endLine","silent"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_block.list.list_block","name":"list_block","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["state","startLine","endLine","silent"],"arg_types":["markdown_it.rules_block.state_block.StateBlock","builtins.int","builtins.int","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"list_block","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"logging":{".class":"SymbolTableNode","cross_ref":"logging","kind":"Gdef"},"markTightParagraphs":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["state","idx"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_block.list.markTightParagraphs","name":"markTightParagraphs","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["state","idx"],"arg_types":["markdown_it.rules_block.state_block.StateBlock","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"markTightParagraphs","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"skipBulletListMarker":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["state","startLine"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_block.list.skipBulletListMarker","name":"skipBulletListMarker","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["state","startLine"],"arg_types":["markdown_it.rules_block.state_block.StateBlock","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"skipBulletListMarker","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"skipOrderedListMarker":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["state","startLine"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_block.list.skipOrderedListMarker","name":"skipOrderedListMarker","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["state","startLine"],"arg_types":["markdown_it.rules_block.state_block.StateBlock","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"skipOrderedListMarker","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_block/list.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/list.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/list.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..4a3d57b40fdc1a7699264054b98dd9c1632a50cf --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/list.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[4,5,2,1,1,1,1,1],"dep_prios":[5,5,10,5,30,30,30,30],"dependencies":["markdown_it.common.utils","markdown_it.rules_block.state_block","logging","builtins","_frozen_importlib","abc","markdown_it.ruler","typing"],"hash":"f6948d5073463eb2c18b47ac0ab6dc9adfe65950","id":"markdown_it.rules_block.list","ignore_all":true,"interface_hash":"f081aa3ff4253f948aea290cf7e2162d866387f6","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_block/list.py","plugin_data":null,"size":9668,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/paragraph.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/paragraph.data.json new file mode 100644 index 0000000000000000000000000000000000000000..9ce949b788a3e22ffd3dcdb94607b11c16790339 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/paragraph.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_block.paragraph","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","LOGGER":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_block.paragraph.LOGGER","name":"LOGGER","setter_type":null,"type":"logging.Logger"}},"StateBlock":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_block.state_block.StateBlock","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.paragraph.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.paragraph.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.paragraph.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.paragraph.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.paragraph.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.paragraph.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"logging":{".class":"SymbolTableNode","cross_ref":"logging","kind":"Gdef"},"paragraph":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["state","startLine","endLine","silent"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_block.paragraph.paragraph","name":"paragraph","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["state","startLine","endLine","silent"],"arg_types":["markdown_it.rules_block.state_block.StateBlock","builtins.int","builtins.int","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"paragraph","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_block/paragraph.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/paragraph.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/paragraph.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..e90bfb13dfa8fcc48752fc298e5d81cdc94be824 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/paragraph.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[5,3,1,1,1,1,1],"dep_prios":[5,10,5,30,30,30,30],"dependencies":["markdown_it.rules_block.state_block","logging","builtins","_frozen_importlib","abc","markdown_it.ruler","typing"],"hash":"c8ba660e9304555c684640983b758611d6b46953","id":"markdown_it.rules_block.paragraph","ignore_all":true,"interface_hash":"3755e958269fa92b6bd2f451978242aba8dd0357","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_block/paragraph.py","plugin_data":null,"size":1819,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/reference.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/reference.data.json new file mode 100644 index 0000000000000000000000000000000000000000..d93f24ef9d9514cda09e6c6c66f6ee7e4ea0d6e9 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/reference.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_block.reference","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","LOGGER":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_block.reference.LOGGER","name":"LOGGER","setter_type":null,"type":"logging.Logger"}},"StateBlock":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_block.state_block.StateBlock","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.reference.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.reference.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.reference.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.reference.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.reference.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.reference.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"charCodeAt":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.utils.charCodeAt","kind":"Gdef"},"getNextLine":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["state","nextLine"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_block.reference.getNextLine","name":"getNextLine","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["state","nextLine"],"arg_types":["markdown_it.rules_block.state_block.StateBlock","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getNextLine","ret_type":{".class":"UnionType","items":[{".class":"NoneType"},"builtins.str"],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isSpace":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.utils.isSpace","kind":"Gdef"},"logging":{".class":"SymbolTableNode","cross_ref":"logging","kind":"Gdef"},"normalizeReference":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.utils.normalizeReference","kind":"Gdef"},"reference":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["state","startLine","_endLine","silent"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_block.reference.reference","name":"reference","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["state","startLine","_endLine","silent"],"arg_types":["markdown_it.rules_block.state_block.StateBlock","builtins.int","builtins.int","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reference","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_block/reference.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/reference.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/reference.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..29b8dc9d9fb5b6ef21d6f2b77edaf3924521478e --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/reference.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[3,4,1,1,1,1,1,1],"dep_prios":[5,5,10,5,30,30,30,30],"dependencies":["markdown_it.common.utils","markdown_it.rules_block.state_block","logging","builtins","_frozen_importlib","abc","markdown_it.ruler","typing"],"hash":"77ca5c5d84ce07ce497e29b9729904748cee3cf4","id":"markdown_it.rules_block.reference","ignore_all":true,"interface_hash":"179af4c78a075250e8454586bf4ebff5526b845a","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_block/reference.py","plugin_data":null,"size":6983,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/state_block.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/state_block.data.json new file mode 100644 index 0000000000000000000000000000000000000000..e95b518f8b5a2bef23e1a155246e1a380d868c8f --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/state_block.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_block.state_block","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","EnvType":{".class":"SymbolTableNode","cross_ref":"markdown_it.utils.EnvType","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"MarkdownIt":{".class":"SymbolTableNode","cross_ref":"markdown_it.main.MarkdownIt","kind":"Gdef"},"StateBase":{".class":"SymbolTableNode","cross_ref":"markdown_it.ruler.StateBase","kind":"Gdef"},"StateBlock":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["markdown_it.ruler.StateBase"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"markdown_it.rules_block.state_block.StateBlock","name":"StateBlock","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"markdown_it.rules_block.state_block.StateBlock","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"markdown_it.rules_block.state_block","mro":["markdown_it.rules_block.state_block.StateBlock","markdown_it.ruler.StateBase","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0],"arg_names":["self","src","md","env","tokens"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"markdown_it.rules_block.state_block.StateBlock.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":["self","src","md","env","tokens"],"arg_types":["markdown_it.rules_block.state_block.StateBlock","builtins.str","markdown_it.main.MarkdownIt",{".class":"TypeAliasType","args":[],"type_ref":"markdown_it.utils.EnvType"},{".class":"Instance","args":["markdown_it.token.Token"],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of StateBlock","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"markdown_it.rules_block.state_block.StateBlock.__repr__","name":"__repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["markdown_it.rules_block.state_block.StateBlock"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr__ of StateBlock","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_code_enabled":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"markdown_it.rules_block.state_block.StateBlock._code_enabled","name":"_code_enabled","setter_type":null,"type":"builtins.bool"}},"bMarks":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"markdown_it.rules_block.state_block.StateBlock.bMarks","name":"bMarks","setter_type":null,"type":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.list"}}},"blkIndent":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"markdown_it.rules_block.state_block.StateBlock.blkIndent","name":"blkIndent","setter_type":null,"type":"builtins.int"}},"bsCount":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"markdown_it.rules_block.state_block.StateBlock.bsCount","name":"bsCount","setter_type":null,"type":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.list"}}},"ddIndent":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"markdown_it.rules_block.state_block.StateBlock.ddIndent","name":"ddIndent","setter_type":null,"type":"builtins.int"}},"eMarks":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"markdown_it.rules_block.state_block.StateBlock.eMarks","name":"eMarks","setter_type":null,"type":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.list"}}},"getLines":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0],"arg_names":["self","begin","end","indent","keepLastLF"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"markdown_it.rules_block.state_block.StateBlock.getLines","name":"getLines","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":["self","begin","end","indent","keepLastLF"],"arg_types":["markdown_it.rules_block.state_block.StateBlock","builtins.int","builtins.int","builtins.int","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getLines of StateBlock","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isEmpty":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","line"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"markdown_it.rules_block.state_block.StateBlock.isEmpty","name":"isEmpty","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","line"],"arg_types":["markdown_it.rules_block.state_block.StateBlock","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isEmpty of StateBlock","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_code_block":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","line"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"markdown_it.rules_block.state_block.StateBlock.is_code_block","name":"is_code_block","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","line"],"arg_types":["markdown_it.rules_block.state_block.StateBlock","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_code_block of StateBlock","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"level":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"markdown_it.rules_block.state_block.StateBlock.level","name":"level","setter_type":null,"type":"builtins.int"}},"line":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"markdown_it.rules_block.state_block.StateBlock.line","name":"line","setter_type":null,"type":"builtins.int"}},"lineMax":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"markdown_it.rules_block.state_block.StateBlock.lineMax","name":"lineMax","setter_type":null,"type":"builtins.int"}},"listIndent":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"markdown_it.rules_block.state_block.StateBlock.listIndent","name":"listIndent","setter_type":null,"type":"builtins.int"}},"parentType":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"markdown_it.rules_block.state_block.StateBlock.parentType","name":"parentType","setter_type":null,"type":"builtins.str"}},"push":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","ttype","tag","nesting"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"markdown_it.rules_block.state_block.StateBlock.push","name":"push","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","ttype","tag","nesting"],"arg_types":["markdown_it.rules_block.state_block.StateBlock","builtins.str","builtins.str",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.int","value":-1},{".class":"LiteralType","fallback":"builtins.int","value":0},{".class":"LiteralType","fallback":"builtins.int","value":1}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"push of StateBlock","ret_type":"markdown_it.token.Token","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"result":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"markdown_it.rules_block.state_block.StateBlock.result","name":"result","setter_type":null,"type":"builtins.str"}},"sCount":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"markdown_it.rules_block.state_block.StateBlock.sCount","name":"sCount","setter_type":null,"type":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.list"}}},"skipChars":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","pos","code"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"markdown_it.rules_block.state_block.StateBlock.skipChars","name":"skipChars","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","pos","code"],"arg_types":["markdown_it.rules_block.state_block.StateBlock","builtins.int","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"skipChars of StateBlock","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"skipCharsBack":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","pos","code","minimum"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"markdown_it.rules_block.state_block.StateBlock.skipCharsBack","name":"skipCharsBack","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","pos","code","minimum"],"arg_types":["markdown_it.rules_block.state_block.StateBlock","builtins.int","builtins.int","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"skipCharsBack of StateBlock","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"skipCharsStr":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","pos","ch"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"markdown_it.rules_block.state_block.StateBlock.skipCharsStr","name":"skipCharsStr","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","pos","ch"],"arg_types":["markdown_it.rules_block.state_block.StateBlock","builtins.int","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"skipCharsStr of StateBlock","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"skipCharsStrBack":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","pos","ch","minimum"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"markdown_it.rules_block.state_block.StateBlock.skipCharsStrBack","name":"skipCharsStrBack","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","pos","ch","minimum"],"arg_types":["markdown_it.rules_block.state_block.StateBlock","builtins.int","builtins.str","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"skipCharsStrBack of StateBlock","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"skipEmptyLines":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","from_pos"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"markdown_it.rules_block.state_block.StateBlock.skipEmptyLines","name":"skipEmptyLines","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","from_pos"],"arg_types":["markdown_it.rules_block.state_block.StateBlock","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"skipEmptyLines of StateBlock","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"skipSpaces":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","pos"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"markdown_it.rules_block.state_block.StateBlock.skipSpaces","name":"skipSpaces","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","pos"],"arg_types":["markdown_it.rules_block.state_block.StateBlock","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"skipSpaces of StateBlock","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"skipSpacesBack":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","pos","minimum"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"markdown_it.rules_block.state_block.StateBlock.skipSpacesBack","name":"skipSpacesBack","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","pos","minimum"],"arg_types":["markdown_it.rules_block.state_block.StateBlock","builtins.int","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"skipSpacesBack of StateBlock","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"tShift":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"markdown_it.rules_block.state_block.StateBlock.tShift","name":"tShift","setter_type":null,"type":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.list"}}},"tight":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"markdown_it.rules_block.state_block.StateBlock.tight","name":"tight","setter_type":null,"type":"builtins.bool"}},"tokens":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"markdown_it.rules_block.state_block.StateBlock.tokens","name":"tokens","setter_type":null,"type":{".class":"Instance","args":["markdown_it.token.Token"],"extra_attrs":null,"type_ref":"builtins.list"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"markdown_it.rules_block.state_block.StateBlock.Self","id":0,"name":"Self","namespace":"","upper_bound":"markdown_it.rules_block.state_block.StateBlock","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"Token":{".class":"SymbolTableNode","cross_ref":"markdown_it.token.Token","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.state_block.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.state_block.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.state_block.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.state_block.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.state_block.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.state_block.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"isStrSpace":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.utils.isStrSpace","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_block/state_block.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/state_block.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/state_block.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..d458eef948be5401237b4f060d0614bc24e47454 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/state_block.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[5,6,7,8,11,1,3,1,1,1,1,1],"dep_prios":[5,5,5,5,25,5,5,5,30,30,30,30],"dependencies":["markdown_it.common.utils","markdown_it.ruler","markdown_it.token","markdown_it.utils","markdown_it.main","__future__","typing","builtins","_frozen_importlib","abc","markdown_it.common","markdown_it.parser_block"],"hash":"e3c45627c883d586ec2d9990be8eb4248918f49e","id":"markdown_it.rules_block.state_block","ignore_all":true,"interface_hash":"7d7c5b611b0aaa8e79a7b9bd631f86d5152e3f39","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_block/state_block.py","plugin_data":null,"size":8422,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/table.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/table.data.json new file mode 100644 index 0000000000000000000000000000000000000000..0c64aca70f5fac015619dd20f007200c7c10e829 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/table.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_block.table","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","MAX_AUTOCOMPLETED_CELLS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_block.table.MAX_AUTOCOMPLETED_CELLS","name":"MAX_AUTOCOMPLETED_CELLS","setter_type":null,"type":"builtins.int"}},"StateBlock":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_block.state_block.StateBlock","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.table.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.table.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.table.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.table.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.table.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_block.table.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"charStrAt":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.utils.charStrAt","kind":"Gdef"},"enclosingPipesRe":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_block.table.enclosingPipesRe","name":"enclosingPipesRe","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"escapedSplit":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["string"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_block.table.escapedSplit","name":"escapedSplit","original_first_arg":"string","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["string"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"escapedSplit","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"getLine":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["state","line"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_block.table.getLine","name":"getLine","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["state","line"],"arg_types":["markdown_it.rules_block.state_block.StateBlock","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getLine","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"headerLineRe":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_block.table.headerLineRe","name":"headerLineRe","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"isStrSpace":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.utils.isStrSpace","kind":"Gdef"},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef"},"table":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["state","startLine","endLine","silent"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_block.table.table","name":"table","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["state","startLine","endLine","silent"],"arg_types":["markdown_it.rules_block.state_block.StateBlock","builtins.int","builtins.int","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"table","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_block/table.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/table.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/table.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..257e1aba77f1fb6b620c93f403a6fa2a4676bf13 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_block/table.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[6,7,2,4,1,1,1,1,1,1],"dep_prios":[5,5,5,10,5,30,30,30,30,30],"dependencies":["markdown_it.common.utils","markdown_it.rules_block.state_block","__future__","re","builtins","_frozen_importlib","abc","enum","markdown_it.ruler","typing"],"hash":"1fc860e4d26565232ee3b11f5116df3fe62cff20","id":"markdown_it.rules_block.table","ignore_all":true,"interface_hash":"2552e926aa8a8a7160e1bef357b268dad9905362","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_block/table.py","plugin_data":null,"size":7682,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..f14c71b0c4addd417660fe328ae0e7415701dd20 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_core","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","StateCore":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_core.state_core.StateCore","kind":"Gdef"},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_core.__all__","name":"__all__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"block":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_core.block.block","kind":"Gdef"},"inline":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_core.inline.inline","kind":"Gdef"},"linkify":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_core.linkify.linkify","kind":"Gdef"},"normalize":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_core.normalize.normalize","kind":"Gdef"},"replace":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_core.replacements.replace","kind":"Gdef"},"smartquotes":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_core.smartquotes.smartquotes","kind":"Gdef"},"text_join":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_core.text_join.text_join","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_core/__init__.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..70965ea6024f45cc3da4f639055d8520653197a3 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[12,13,14,15,16,17,18,19,1,1,1,1],"dep_prios":[5,5,5,5,5,5,5,5,5,30,30,30],"dependencies":["markdown_it.rules_core.block","markdown_it.rules_core.inline","markdown_it.rules_core.linkify","markdown_it.rules_core.normalize","markdown_it.rules_core.replacements","markdown_it.rules_core.smartquotes","markdown_it.rules_core.state_core","markdown_it.rules_core.text_join","builtins","_frozen_importlib","abc","typing"],"hash":"07320212f34d9cf255799d6f361a715d975c25da","id":"markdown_it.rules_core","ignore_all":true,"interface_hash":"34b4bfac560bc16fdffca8b1ee3ee159644925b5","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_core/__init__.py","plugin_data":null,"size":394,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/block.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/block.data.json new file mode 100644 index 0000000000000000000000000000000000000000..eb85ceaa199737e140fafd03151ad3522ce9c4da --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/block.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_core.block","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","StateCore":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_core.state_core.StateCore","kind":"Gdef"},"Token":{".class":"SymbolTableNode","cross_ref":"markdown_it.token.Token","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.block.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.block.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.block.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.block.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.block.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.block.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"block":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["state"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_core.block.block","name":"block","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["state"],"arg_types":["markdown_it.rules_core.state_core.StateCore"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"block","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_core/block.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/block.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/block.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..3c6478b8405d325afab60930548260d971a3bb0f --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/block.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[2,1,1,1,1,1,1],"dep_prios":[5,5,5,30,30,30,30],"dependencies":["markdown_it.rules_core.state_core","markdown_it.token","builtins","_frozen_importlib","abc","markdown_it.ruler","typing"],"hash":"781e3e5321790a6f0af0117c84060dace664941f","id":"markdown_it.rules_core.block","ignore_all":true,"interface_hash":"ffcae8944045d4bb6f928d33da4a29a520379b9e","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_core/block.py","plugin_data":null,"size":372,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/inline.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/inline.data.json new file mode 100644 index 0000000000000000000000000000000000000000..5d1f424815a2401e2c16462a78038a5249d18947 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/inline.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_core.inline","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","StateCore":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_core.state_core.StateCore","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.inline.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.inline.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.inline.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.inline.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.inline.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.inline.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"inline":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["state"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_core.inline.inline","name":"inline","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["state"],"arg_types":["markdown_it.rules_core.state_core.StateCore"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"inline","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_core/inline.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/inline.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/inline.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..b887969d9b60158329e1bb90841d2c918ed81053 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/inline.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[1,1,1,1,1,1],"dep_prios":[5,5,30,30,30,30],"dependencies":["markdown_it.rules_core.state_core","builtins","_frozen_importlib","abc","markdown_it.ruler","typing"],"hash":"9d2bdc28338a8e15ad1d370419dfe696b780aad0","id":"markdown_it.rules_core.inline","ignore_all":true,"interface_hash":"80e13b537d7c6bc76b1cc1a1f117d9ce5499aa49","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_core/inline.py","plugin_data":null,"size":325,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/linkify.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/linkify.data.json new file mode 100644 index 0000000000000000000000000000000000000000..fa66b2c77fe90c36118e2d76b95f6f07fcec6b3b --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/linkify.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_core.linkify","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","HTTP_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_core.linkify.HTTP_RE","name":"HTTP_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"MAILTO_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_core.linkify.MAILTO_RE","name":"MAILTO_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"Protocol":{".class":"SymbolTableNode","cross_ref":"typing.Protocol","kind":"Gdef"},"StateCore":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_core.state_core.StateCore","kind":"Gdef"},"TEST_MAILTO_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_core.linkify.TEST_MAILTO_RE","name":"TEST_MAILTO_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"Token":{".class":"SymbolTableNode","cross_ref":"markdown_it.token.Token","kind":"Gdef"},"_LinkType":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[["index",1],["last_index",1],["schema",1],["text",1],["url",1]],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"markdown_it.rules_core.linkify._LinkType","name":"_LinkType","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_abstract","is_protocol"],"fullname":"markdown_it.rules_core.linkify._LinkType","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"markdown_it.rules_core.linkify","mro":["markdown_it.rules_core.linkify._LinkType","builtins.object"],"names":{".class":"SymbolTable","index":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_abstract_var","is_ready"],"fullname":"markdown_it.rules_core.linkify._LinkType.index","name":"index","setter_type":null,"type":"builtins.int"}},"last_index":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_abstract_var","is_ready"],"fullname":"markdown_it.rules_core.linkify._LinkType.last_index","name":"last_index","setter_type":null,"type":"builtins.int"}},"schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_abstract_var","is_ready"],"fullname":"markdown_it.rules_core.linkify._LinkType.schema","name":"schema","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"text":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_abstract_var","is_ready"],"fullname":"markdown_it.rules_core.linkify._LinkType.text","name":"text","setter_type":null,"type":"builtins.str"}},"url":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_abstract_var","is_ready"],"fullname":"markdown_it.rules_core.linkify._LinkType.url","name":"url","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"markdown_it.rules_core.linkify._LinkType.Self","id":0,"name":"Self","namespace":"","upper_bound":"markdown_it.rules_core.linkify._LinkType","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.linkify.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.linkify.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.linkify.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.linkify.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.linkify.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.linkify.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"arrayReplaceAt":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.utils.arrayReplaceAt","kind":"Gdef"},"isLinkClose":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.utils.isLinkClose","kind":"Gdef"},"isLinkOpen":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.utils.isLinkOpen","kind":"Gdef"},"linkify":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["state"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_core.linkify.linkify","name":"linkify","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["state"],"arg_types":["markdown_it.rules_core.state_core.StateCore"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"linkify","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_core/linkify.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/linkify.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/linkify.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..52694b16ec101ad7f31a351788eab33fa891ede3 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/linkify.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[6,8,7,1,3,4,1,1,1,1,1],"dep_prios":[5,5,5,5,10,5,5,30,30,30,30],"dependencies":["markdown_it.common.utils","markdown_it.rules_core.state_core","markdown_it.token","__future__","re","typing","builtins","_frozen_importlib","abc","enum","markdown_it.ruler"],"hash":"09336134313b7acfc32ac994a6cf3a8ffc03d692","id":"markdown_it.rules_core.linkify","ignore_all":true,"interface_hash":"d495ff57460a39621992a62f953d92863f9722e4","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_core/linkify.py","plugin_data":null,"size":5141,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/normalize.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/normalize.data.json new file mode 100644 index 0000000000000000000000000000000000000000..cfd4c9197274e1e8ab7652edeb8dda39ac6113e5 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/normalize.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_core.normalize","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","NEWLINES_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_core.normalize.NEWLINES_RE","name":"NEWLINES_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"NULL_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_core.normalize.NULL_RE","name":"NULL_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"StateCore":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_core.state_core.StateCore","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.normalize.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.normalize.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.normalize.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.normalize.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.normalize.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.normalize.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"normalize":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["state"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_core.normalize.normalize","name":"normalize","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["state"],"arg_types":["markdown_it.rules_core.state_core.StateCore"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"normalize","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_core/normalize.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/normalize.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/normalize.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..0cf31353ca8a2215b0a074f330dd2c7ed663f08a --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/normalize.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[5,3,1,1,1,1,1,1],"dep_prios":[5,10,5,30,30,30,30,30],"dependencies":["markdown_it.rules_core.state_core","re","builtins","_frozen_importlib","abc","enum","markdown_it.ruler","typing"],"hash":"0bd67bde801cc7b85616c0b0795edc0f758676c1","id":"markdown_it.rules_core.normalize","ignore_all":true,"interface_hash":"748c1012da5555c16afc2439bf18f38a8d8e74ad","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_core/normalize.py","plugin_data":null,"size":403,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/replacements.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/replacements.data.json new file mode 100644 index 0000000000000000000000000000000000000000..093339869fd6846ad58d7c3bcbd64829942858a6 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/replacements.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_core.replacements","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","COMMA_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_core.replacements.COMMA_RE","name":"COMMA_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"ELLIPSIS_QUESTION_EXCLAMATION_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_core.replacements.ELLIPSIS_QUESTION_EXCLAMATION_RE","name":"ELLIPSIS_QUESTION_EXCLAMATION_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"ELLIPSIS_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_core.replacements.ELLIPSIS_RE","name":"ELLIPSIS_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"EM_DASH_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_core.replacements.EM_DASH_RE","name":"EM_DASH_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"EN_DASH_INDENT_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_core.replacements.EN_DASH_INDENT_RE","name":"EN_DASH_INDENT_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"EN_DASH_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_core.replacements.EN_DASH_RE","name":"EN_DASH_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"LOGGER":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_core.replacements.LOGGER","name":"LOGGER","setter_type":null,"type":"logging.Logger"}},"PLUS_MINUS_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_core.replacements.PLUS_MINUS_RE","name":"PLUS_MINUS_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"QUESTION_EXCLAMATION_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_core.replacements.QUESTION_EXCLAMATION_RE","name":"QUESTION_EXCLAMATION_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"RARE_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_core.replacements.RARE_RE","name":"RARE_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"SCOPED_ABBR":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_core.replacements.SCOPED_ABBR","name":"SCOPED_ABBR","setter_type":null,"type":{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"SCOPED_ABBR_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_core.replacements.SCOPED_ABBR_RE","name":"SCOPED_ABBR_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"StateCore":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_core.state_core.StateCore","kind":"Gdef"},"Token":{".class":"SymbolTableNode","cross_ref":"markdown_it.token.Token","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.replacements.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.replacements.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.replacements.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.replacements.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.replacements.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.replacements.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"logging":{".class":"SymbolTableNode","cross_ref":"logging","kind":"Gdef"},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef"},"replace":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["state"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_core.replacements.replace","name":"replace","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["state"],"arg_types":["markdown_it.rules_core.state_core.StateCore"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"replaceFn":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["match"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_core.replacements.replaceFn","name":"replaceFn","original_first_arg":"match","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["match"],"arg_types":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Match"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replaceFn","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"replace_rare":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["inlineTokens"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_core.replacements.replace_rare","name":"replace_rare","original_first_arg":"inlineTokens","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["inlineTokens"],"arg_types":[{".class":"Instance","args":["markdown_it.token.Token"],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace_rare","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"replace_scoped":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["inlineTokens"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_core.replacements.replace_scoped","name":"replace_scoped","original_first_arg":"inlineTokens","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["inlineTokens"],"arg_types":[{".class":"Instance","args":["markdown_it.token.Token"],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace_scoped","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_core/replacements.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/replacements.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/replacements.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..c02f33e5c1f618e5821fdbb29aeb2eb004be4864 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/replacements.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[23,22,17,19,20,1,1,1,1,1,1],"dep_prios":[5,5,5,10,10,5,30,30,30,30,30],"dependencies":["markdown_it.rules_core.state_core","markdown_it.token","__future__","logging","re","builtins","_frozen_importlib","abc","enum","markdown_it.ruler","typing"],"hash":"a86bbed045d1a95ef1049bdd142c384827c19a7d","id":"markdown_it.rules_core.replacements","ignore_all":true,"interface_hash":"ff0baee9c66d1c1be1cc4328aa2665abfaaab4a4","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_core/replacements.py","plugin_data":null,"size":3471,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/smartquotes.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/smartquotes.data.json new file mode 100644 index 0000000000000000000000000000000000000000..6fae6425ebff9cf8635f9f8fe10eef084609fe12 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/smartquotes.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_core.smartquotes","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","APOSTROPHE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_core.smartquotes.APOSTROPHE","name":"APOSTROPHE","setter_type":null,"type":"builtins.str"}},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"QUOTE_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_core.smartquotes.QUOTE_RE","name":"QUOTE_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"QUOTE_TEST_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_core.smartquotes.QUOTE_TEST_RE","name":"QUOTE_TEST_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"StateCore":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_core.state_core.StateCore","kind":"Gdef"},"Token":{".class":"SymbolTableNode","cross_ref":"markdown_it.token.Token","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.smartquotes.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.smartquotes.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.smartquotes.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.smartquotes.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.smartquotes.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.smartquotes.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"charCodeAt":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.utils.charCodeAt","kind":"Gdef"},"isMdAsciiPunct":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.utils.isMdAsciiPunct","kind":"Gdef"},"isPunctChar":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.utils.isPunctChar","kind":"Gdef"},"isWhiteSpace":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.utils.isWhiteSpace","kind":"Gdef"},"process_inlines":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["tokens","state"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_core.smartquotes.process_inlines","name":"process_inlines","original_first_arg":"tokens","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["tokens","state"],"arg_types":[{".class":"Instance","args":["markdown_it.token.Token"],"extra_attrs":null,"type_ref":"builtins.list"},"markdown_it.rules_core.state_core.StateCore"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"process_inlines","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef"},"replaceAt":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["string","index","ch"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_core.smartquotes.replaceAt","name":"replaceAt","original_first_arg":"string","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["string","index","ch"],"arg_types":["builtins.str","builtins.int","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replaceAt","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"smartquotes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["state"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_core.smartquotes.smartquotes","name":"smartquotes","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["state"],"arg_types":["markdown_it.rules_core.state_core.StateCore"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"smartquotes","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_core/smartquotes.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/smartquotes.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/smartquotes.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..82c3ea056e3c59f90403f903fc054d4b86d151f0 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/smartquotes.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[8,10,9,3,5,6,1,1,1,1,1],"dep_prios":[5,5,5,5,10,5,5,30,30,30,30],"dependencies":["markdown_it.common.utils","markdown_it.rules_core.state_core","markdown_it.token","__future__","re","typing","builtins","_frozen_importlib","abc","enum","markdown_it.ruler"],"hash":"8447120dbe796289c452568b2a2e63e0e719bed1","id":"markdown_it.rules_core.smartquotes","ignore_all":true,"interface_hash":"7ad765ddb5c43e407f8062c44971808abea48ee2","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_core/smartquotes.py","plugin_data":null,"size":7443,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/state_core.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/state_core.data.json new file mode 100644 index 0000000000000000000000000000000000000000..71b32a56d135637a4ae1ea1331746300f004ea1e --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/state_core.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_core.state_core","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","EnvType":{".class":"SymbolTableNode","cross_ref":"markdown_it.utils.EnvType","kind":"Gdef"},"MarkdownIt":{".class":"SymbolTableNode","cross_ref":"markdown_it.main.MarkdownIt","kind":"Gdef"},"StateBase":{".class":"SymbolTableNode","cross_ref":"markdown_it.ruler.StateBase","kind":"Gdef"},"StateCore":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["markdown_it.ruler.StateBase"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"markdown_it.rules_core.state_core.StateCore","name":"StateCore","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"markdown_it.rules_core.state_core.StateCore","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"markdown_it.rules_core.state_core","mro":["markdown_it.rules_core.state_core.StateCore","markdown_it.ruler.StateBase","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1],"arg_names":["self","src","md","env","tokens"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"markdown_it.rules_core.state_core.StateCore.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","src","md","env","tokens"],"arg_types":["markdown_it.rules_core.state_core.StateCore","builtins.str","markdown_it.main.MarkdownIt",{".class":"TypeAliasType","args":[],"type_ref":"markdown_it.utils.EnvType"},{".class":"UnionType","items":[{".class":"Instance","args":["markdown_it.token.Token"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of StateCore","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"inlineMode":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"markdown_it.rules_core.state_core.StateCore.inlineMode","name":"inlineMode","setter_type":null,"type":"builtins.bool"}},"tokens":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"markdown_it.rules_core.state_core.StateCore.tokens","name":"tokens","setter_type":null,"type":{".class":"Instance","args":["markdown_it.token.Token"],"extra_attrs":null,"type_ref":"builtins.list"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"markdown_it.rules_core.state_core.StateCore.Self","id":0,"name":"Self","namespace":"","upper_bound":"markdown_it.rules_core.state_core.StateCore","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"Token":{".class":"SymbolTableNode","cross_ref":"markdown_it.token.Token","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.state_core.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.state_core.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.state_core.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.state_core.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.state_core.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.state_core.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_core/state_core.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/state_core.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/state_core.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..0ba4f4473a5fb234267861149191926428f5399c --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/state_core.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[5,6,7,1,3,10,1,1,1,1],"dep_prios":[5,5,5,5,5,25,5,30,30,30],"dependencies":["markdown_it.ruler","markdown_it.token","markdown_it.utils","__future__","typing","markdown_it","builtins","_frozen_importlib","abc","markdown_it.main"],"hash":"63d239662a6269258840065179f690331015e57a","id":"markdown_it.rules_core.state_core","ignore_all":true,"interface_hash":"9597194848040e1420aa435af211f50d164d9022","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_core/state_core.py","plugin_data":null,"size":570,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/text_join.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/text_join.data.json new file mode 100644 index 0000000000000000000000000000000000000000..7156029acfd1e0fb9d1d8bab4a3f95e98c75d033 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/text_join.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_core.text_join","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","StateCore":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_core.state_core.StateCore","kind":"Gdef"},"Token":{".class":"SymbolTableNode","cross_ref":"markdown_it.token.Token","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.text_join.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.text_join.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.text_join.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.text_join.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.text_join.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_core.text_join.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"text_join":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["state"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_core.text_join.text_join","name":"text_join","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["state"],"arg_types":["markdown_it.rules_core.state_core.StateCore"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text_join","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_core/text_join.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/text_join.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/text_join.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..215897a49afb958f785486643531151471791ea5 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_core/text_join.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[12,11,9,1,1,1,1,1],"dep_prios":[5,5,5,5,30,30,30,30],"dependencies":["markdown_it.rules_core.state_core","markdown_it.token","__future__","builtins","_frozen_importlib","abc","markdown_it.ruler","typing"],"hash":"c117c44942265ab44bb32a3f036e9341ed971b22","id":"markdown_it.rules_core.text_join","ignore_all":true,"interface_hash":"b7711af2e9cd4e64da05c67949ee8d99d140177f","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_core/text_join.py","plugin_data":null,"size":1173,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..386341a6725b87a959fc2450778512255766d525 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_inline","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","StateInline":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_inline.state_inline.StateInline","kind":"Gdef"},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_inline.__all__","name":"__all__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"autolink":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_inline.autolink.autolink","kind":"Gdef"},"backtick":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_inline.backticks.backtick","kind":"Gdef"},"emphasis":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_inline.emphasis","kind":"Gdef"},"entity":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_inline.entity.entity","kind":"Gdef"},"escape":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_inline.escape.escape","kind":"Gdef"},"fragments_join":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_inline.fragments_join.fragments_join","kind":"Gdef"},"html_inline":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_inline.html_inline.html_inline","kind":"Gdef"},"image":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_inline.image.image","kind":"Gdef"},"link":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_inline.link.link","kind":"Gdef"},"link_pairs":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_inline.balance_pairs.link_pairs","kind":"Gdef"},"linkify":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_inline.linkify.linkify","kind":"Gdef"},"newline":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_inline.newline.newline","kind":"Gdef"},"strikethrough":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_inline.strikethrough","kind":"Gdef"},"text":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_inline.text.text","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_inline/__init__.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..d1a12b14005b42fe1074df59109a665b68240564 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[18,18,19,20,21,22,23,24,25,26,27,28,29,30,31,1,1,1,1],"dep_prios":[10,10,5,5,5,5,5,5,5,5,5,5,5,5,5,5,30,30,30],"dependencies":["markdown_it.rules_inline.emphasis","markdown_it.rules_inline.strikethrough","markdown_it.rules_inline.autolink","markdown_it.rules_inline.backticks","markdown_it.rules_inline.balance_pairs","markdown_it.rules_inline.entity","markdown_it.rules_inline.escape","markdown_it.rules_inline.fragments_join","markdown_it.rules_inline.html_inline","markdown_it.rules_inline.image","markdown_it.rules_inline.link","markdown_it.rules_inline.linkify","markdown_it.rules_inline.newline","markdown_it.rules_inline.state_inline","markdown_it.rules_inline.text","builtins","_frozen_importlib","abc","typing"],"hash":"b9d41e60db19b2d4f64e1b7b28f50e60dd4c3ac7","id":"markdown_it.rules_inline","ignore_all":true,"interface_hash":"ce2cf7fa39ac2e0eb5f9edcda2fca5bfbce24a4d","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_inline/__init__.py","plugin_data":null,"size":696,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/autolink.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/autolink.data.json new file mode 100644 index 0000000000000000000000000000000000000000..a3be9c61385d662b0d137f855d5f270187314191 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/autolink.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_inline.autolink","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","AUTOLINK_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_inline.autolink.AUTOLINK_RE","name":"AUTOLINK_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"EMAIL_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_inline.autolink.EMAIL_RE","name":"EMAIL_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"StateInline":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_inline.state_inline.StateInline","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.autolink.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.autolink.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.autolink.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.autolink.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.autolink.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.autolink.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"autolink":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["state","silent"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_inline.autolink.autolink","name":"autolink","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["state","silent"],"arg_types":["markdown_it.rules_inline.state_inline.StateInline","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"autolink","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_inline/autolink.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/autolink.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/autolink.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..cbf4840b152a098cbf23fd8bc65b2751d32e95c7 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/autolink.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[4,2,1,1,1,1,1,1],"dep_prios":[5,10,5,30,30,30,30,30],"dependencies":["markdown_it.rules_inline.state_inline","re","builtins","_frozen_importlib","abc","enum","markdown_it.ruler","typing"],"hash":"cfe3d434527bb630f2ef8192e2b7fc0281c5d9ae","id":"markdown_it.rules_inline.autolink","ignore_all":true,"interface_hash":"915d04f1f7a21bc14b66a1f7ee22cc10d5052d8a","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_inline/autolink.py","plugin_data":null,"size":2065,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/backticks.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/backticks.data.json new file mode 100644 index 0000000000000000000000000000000000000000..6e93e9011de83a2c279b3ef228049ff3b232156c --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/backticks.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_inline.backticks","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","StateInline":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_inline.state_inline.StateInline","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.backticks.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.backticks.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.backticks.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.backticks.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.backticks.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.backticks.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"backtick":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["state","silent"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_inline.backticks.backtick","name":"backtick","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["state","silent"],"arg_types":["markdown_it.rules_inline.state_inline.StateInline","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"backtick","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef"},"regex":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_inline.backticks.regex","name":"regex","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_inline/backticks.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/backticks.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/backticks.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..da34cab7bc28b19f145f58d72fa310f6fdfac801 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/backticks.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[4,2,1,1,1,1,1,1],"dep_prios":[5,10,5,30,30,30,30,30],"dependencies":["markdown_it.rules_inline.state_inline","re","builtins","_frozen_importlib","abc","enum","markdown_it.ruler","typing"],"hash":"182685d3db57f8b158cbe40aed25f5c4ad5707a6","id":"markdown_it.rules_inline.backticks","ignore_all":true,"interface_hash":"d05f85b33dff6bb567d74d3f8aede78cefd90635","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_inline/backticks.py","plugin_data":null,"size":2037,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/balance_pairs.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/balance_pairs.data.json new file mode 100644 index 0000000000000000000000000000000000000000..7cd0e29f1754bcfb3e482df9283097378bb0701a --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/balance_pairs.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_inline.balance_pairs","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Delimiter":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_inline.state_inline.Delimiter","kind":"Gdef"},"StateInline":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_inline.state_inline.StateInline","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.balance_pairs.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.balance_pairs.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.balance_pairs.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.balance_pairs.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.balance_pairs.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.balance_pairs.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"link_pairs":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["state"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_inline.balance_pairs.link_pairs","name":"link_pairs","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["state"],"arg_types":["markdown_it.rules_inline.state_inline.StateInline"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"link_pairs","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"processDelimiters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["state","delimiters"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_inline.balance_pairs.processDelimiters","name":"processDelimiters","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["state","delimiters"],"arg_types":["markdown_it.rules_inline.state_inline.StateInline",{".class":"Instance","args":["markdown_it.rules_inline.state_inline.Delimiter"],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"processDelimiters","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_inline/balance_pairs.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/balance_pairs.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/balance_pairs.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..c96f1aa822142fb8405c8d821a090a1712c334ef --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/balance_pairs.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[5,3,1,1,1,1,1],"dep_prios":[5,5,5,30,30,30,30],"dependencies":["markdown_it.rules_inline.state_inline","__future__","builtins","_frozen_importlib","abc","markdown_it.ruler","typing"],"hash":"3deaf4abb7635533e3c2b82a7124e7f2950e16f0","id":"markdown_it.rules_inline.balance_pairs","ignore_all":true,"interface_hash":"04f1e53eb9e75fbae6c8d2e7e4b9a2eaaaf7be43","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_inline/balance_pairs.py","plugin_data":null,"size":4852,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/emphasis.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/emphasis.data.json new file mode 100644 index 0000000000000000000000000000000000000000..ab3c6b090c1489ce19b9c3293a1685dfbbacd2db --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/emphasis.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_inline.emphasis","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Delimiter":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_inline.state_inline.Delimiter","kind":"Gdef"},"StateInline":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_inline.state_inline.StateInline","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.emphasis.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.emphasis.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.emphasis.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.emphasis.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.emphasis.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.emphasis.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_postProcess":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["state","delimiters"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_inline.emphasis._postProcess","name":"_postProcess","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["state","delimiters"],"arg_types":["markdown_it.rules_inline.state_inline.StateInline",{".class":"Instance","args":["markdown_it.rules_inline.state_inline.Delimiter"],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_postProcess","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"postProcess":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["state"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_inline.emphasis.postProcess","name":"postProcess","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["state"],"arg_types":["markdown_it.rules_inline.state_inline.StateInline"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"postProcess","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"tokenize":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["state","silent"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_inline.emphasis.tokenize","name":"tokenize","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["state","silent"],"arg_types":["markdown_it.rules_inline.state_inline.StateInline","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tokenize","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_inline/emphasis.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/emphasis.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/emphasis.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..6ad9f9c588b5d75c168ebe76c305a0ba0b1621c6 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/emphasis.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[5,3,1,1,1,1,1],"dep_prios":[5,5,5,30,30,30,30],"dependencies":["markdown_it.rules_inline.state_inline","__future__","builtins","_frozen_importlib","abc","markdown_it.ruler","typing"],"hash":"c726d3a777fbd72d57d4253992af186a4ee1696d","id":"markdown_it.rules_inline.emphasis","ignore_all":true,"interface_hash":"051b5e823f2cac3902be82b500f324626ced1e59","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_inline/emphasis.py","plugin_data":null,"size":3123,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/entity.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/entity.data.json new file mode 100644 index 0000000000000000000000000000000000000000..8cdff0733d7c6af2c1f7e7d11674a77f50874ba8 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/entity.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_inline.entity","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","DIGITAL_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_inline.entity.DIGITAL_RE","name":"DIGITAL_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"NAMED_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_inline.entity.NAMED_RE","name":"NAMED_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"StateInline":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_inline.state_inline.StateInline","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.entity.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.entity.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.entity.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.entity.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.entity.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.entity.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"entities":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.entities.entities","kind":"Gdef"},"entity":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["state","silent"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_inline.entity.entity","name":"entity","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["state","silent"],"arg_types":["markdown_it.rules_inline.state_inline.StateInline","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"entity","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"fromCodePoint":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.utils.fromCodePoint","kind":"Gdef"},"isValidEntityCode":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.utils.isValidEntityCode","kind":"Gdef"},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_inline/entity.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/entity.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/entity.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..0ab6830bd00943a39276a075e74e23ff736c6d26 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/entity.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[4,5,6,2,1,1,1,1,1,1],"dep_prios":[5,5,5,10,5,30,30,30,30,30],"dependencies":["markdown_it.common.entities","markdown_it.common.utils","markdown_it.rules_inline.state_inline","re","builtins","_frozen_importlib","abc","enum","markdown_it.ruler","typing"],"hash":"8f19cfb47ef3a7eb5a86020489251c19e8ad4c71","id":"markdown_it.rules_inline.entity","ignore_all":true,"interface_hash":"6ee887139983bb20e6b3333ffd4efb3c9295ccf3","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_inline/entity.py","plugin_data":null,"size":1651,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/escape.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/escape.data.json new file mode 100644 index 0000000000000000000000000000000000000000..e18e34fa6d93e842e7b186926bcd4a518a194959 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/escape.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_inline.escape","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","StateInline":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_inline.state_inline.StateInline","kind":"Gdef"},"_ESCAPED":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_inline.escape._ESCAPED","name":"_ESCAPED","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.escape.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.escape.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.escape.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.escape.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.escape.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.escape.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"escape":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["state","silent"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_inline.escape.escape","name":"escape","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["state","silent"],"arg_types":["markdown_it.rules_inline.state_inline.StateInline","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"escape","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isStrSpace":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.utils.isStrSpace","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_inline/escape.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/escape.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/escape.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..7a460d19205f98160ff553f9aeda515f1eef5c1e --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/escape.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[5,6,1,1,1,1,1],"dep_prios":[5,5,5,30,30,30,30],"dependencies":["markdown_it.common.utils","markdown_it.rules_inline.state_inline","builtins","_frozen_importlib","abc","markdown_it.ruler","typing"],"hash":"a419d9312345e9259df62086ca31a456380235af","id":"markdown_it.rules_inline.escape","ignore_all":true,"interface_hash":"c2346ce2f0e959d50f1b6b8b2c811e186305f688","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_inline/escape.py","plugin_data":null,"size":1659,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/fragments_join.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/fragments_join.data.json new file mode 100644 index 0000000000000000000000000000000000000000..760c85645a8ef056ccac8128f62667f31d21a475 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/fragments_join.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_inline.fragments_join","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","StateInline":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_inline.state_inline.StateInline","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.fragments_join.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.fragments_join.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.fragments_join.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.fragments_join.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.fragments_join.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.fragments_join.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"fragments_join":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["state"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_inline.fragments_join.fragments_join","name":"fragments_join","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["state"],"arg_types":["markdown_it.rules_inline.state_inline.StateInline"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fragments_join","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_inline/fragments_join.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/fragments_join.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/fragments_join.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..fd08b2cfb3cd3fbaae714755909c24154b6adb78 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/fragments_join.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[1,1,1,1,1,1],"dep_prios":[5,5,30,30,30,30],"dependencies":["markdown_it.rules_inline.state_inline","builtins","_frozen_importlib","abc","markdown_it.ruler","typing"],"hash":"f954632967d1bbcb6d108c4b1691c37a2c5d991e","id":"markdown_it.rules_inline.fragments_join","ignore_all":true,"interface_hash":"b8d1482828eb2b2b4a49d3c3e5b63741f1a210a4","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_inline/fragments_join.py","plugin_data":null,"size":1493,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/html_inline.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/html_inline.data.json new file mode 100644 index 0000000000000000000000000000000000000000..80def8ecae8cd95d86b7d65198376c8081e4dfcc --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/html_inline.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_inline.html_inline","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","HTML_TAG_RE":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.html_re.HTML_TAG_RE","kind":"Gdef"},"StateInline":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_inline.state_inline.StateInline","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.html_inline.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.html_inline.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.html_inline.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.html_inline.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.html_inline.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.html_inline.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"html_inline":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["state","silent"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_inline.html_inline.html_inline","name":"html_inline","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["state","silent"],"arg_types":["markdown_it.rules_inline.state_inline.StateInline","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"html_inline","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isLetter":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["ch"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_inline.html_inline.isLetter","name":"isLetter","original_first_arg":"ch","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["ch"],"arg_types":["builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isLetter","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isLinkClose":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.utils.isLinkClose","kind":"Gdef"},"isLinkOpen":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.utils.isLinkOpen","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_inline/html_inline.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/html_inline.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/html_inline.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..f77202a65ca87701f9b81b05ff1efe932ba70292 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/html_inline.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[2,3,4,1,1,1,1,1],"dep_prios":[5,5,5,5,30,30,30,30],"dependencies":["markdown_it.common.html_re","markdown_it.common.utils","markdown_it.rules_inline.state_inline","builtins","_frozen_importlib","abc","markdown_it.ruler","typing"],"hash":"a98c2a338745e851006119eef0374db79bfd9e0d","id":"markdown_it.rules_inline.html_inline","ignore_all":true,"interface_hash":"337f16f41def2b86d631cb1a3d7ee77920b87d63","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_inline/html_inline.py","plugin_data":null,"size":1130,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/image.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/image.data.json new file mode 100644 index 0000000000000000000000000000000000000000..3c0f06d7d11ba199eb440a810ff14d7eeba4aa13 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/image.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_inline.image","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","StateInline":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_inline.state_inline.StateInline","kind":"Gdef"},"Token":{".class":"SymbolTableNode","cross_ref":"markdown_it.token.Token","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.image.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.image.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.image.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.image.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.image.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.image.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"image":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["state","silent"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_inline.image.image","name":"image","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["state","silent"],"arg_types":["markdown_it.rules_inline.state_inline.StateInline","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"image","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isStrSpace":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.utils.isStrSpace","kind":"Gdef"},"normalizeReference":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.utils.normalizeReference","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_inline/image.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/image.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/image.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..eeb0282cea710c61430feb17ebfff4959ab3153a --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/image.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[4,6,5,2,1,1,1,1,1],"dep_prios":[5,5,5,5,5,30,30,30,30],"dependencies":["markdown_it.common.utils","markdown_it.rules_inline.state_inline","markdown_it.token","__future__","builtins","_frozen_importlib","abc","markdown_it.ruler","typing"],"hash":"8ed57945100ed1650c76a5858192db00477ee3d5","id":"markdown_it.rules_inline.image","ignore_all":true,"interface_hash":"94d963f18ffcdc9b8e9a03ed903593a7d1200fb6","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_inline/image.py","plugin_data":null,"size":4141,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/link.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/link.data.json new file mode 100644 index 0000000000000000000000000000000000000000..d54657ee02427297fc844ebddeb7e84903fc4f48 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/link.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_inline.link","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","StateInline":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_inline.state_inline.StateInline","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.link.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.link.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.link.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.link.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.link.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.link.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"isStrSpace":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.utils.isStrSpace","kind":"Gdef"},"link":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["state","silent"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_inline.link.link","name":"link","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["state","silent"],"arg_types":["markdown_it.rules_inline.state_inline.StateInline","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"link","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"normalizeReference":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.utils.normalizeReference","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_inline/link.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/link.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/link.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..d682d688b964ca4eb9448ed15dfca6540ac971dd --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/link.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[3,4,1,1,1,1,1],"dep_prios":[5,5,5,30,30,30,30],"dependencies":["markdown_it.common.utils","markdown_it.rules_inline.state_inline","builtins","_frozen_importlib","abc","markdown_it.ruler","typing"],"hash":"059c67cab0b0ace87f6c0f19658a080a135f8398","id":"markdown_it.rules_inline.link","ignore_all":true,"interface_hash":"b96ee93e38077843fb7d7d5e562dcc6aaf225c22","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_inline/link.py","plugin_data":null,"size":4258,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/linkify.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/linkify.data.json new file mode 100644 index 0000000000000000000000000000000000000000..8086476904aede21c9c77186bb2494e0944fe0ee --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/linkify.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_inline.linkify","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","SCHEME_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_inline.linkify.SCHEME_RE","name":"SCHEME_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"StateInline":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_inline.state_inline.StateInline","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.linkify.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.linkify.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.linkify.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.linkify.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.linkify.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.linkify.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"linkify":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["state","silent"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_inline.linkify.linkify","name":"linkify","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["state","silent"],"arg_types":["markdown_it.rules_inline.state_inline.StateInline","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"linkify","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_inline/linkify.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/linkify.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/linkify.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..ca661c5fd2468fd1163c3e67d1cf0a79201cf5e2 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/linkify.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[5,3,1,1,1,1,1,1],"dep_prios":[5,10,5,30,30,30,30,30],"dependencies":["markdown_it.rules_inline.state_inline","re","builtins","_frozen_importlib","abc","enum","markdown_it.ruler","typing"],"hash":"463d6eff5b53666f7640ef00884fe8934c3cba72","id":"markdown_it.rules_inline.linkify","ignore_all":true,"interface_hash":"be432789617da9b9d291b24eff3ff48c5b76fbea","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_inline/linkify.py","plugin_data":null,"size":1706,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/newline.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/newline.data.json new file mode 100644 index 0000000000000000000000000000000000000000..938bb98b389058358491229adcf412274a9ba002 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/newline.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_inline.newline","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","StateInline":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_inline.state_inline.StateInline","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.newline.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.newline.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.newline.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.newline.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.newline.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.newline.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"charStrAt":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.utils.charStrAt","kind":"Gdef"},"isStrSpace":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.utils.isStrSpace","kind":"Gdef"},"newline":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["state","silent"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_inline.newline.newline","name":"newline","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["state","silent"],"arg_types":["markdown_it.rules_inline.state_inline.StateInline","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"newline","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_inline/newline.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/newline.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/newline.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..284222a2f760b394881fc0aa2ada3fcb649ed940 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/newline.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[3,4,1,1,1,1,1],"dep_prios":[5,5,5,30,30,30,30],"dependencies":["markdown_it.common.utils","markdown_it.rules_inline.state_inline","builtins","_frozen_importlib","abc","markdown_it.ruler","typing"],"hash":"3770849abc8cf4136e16594de18405a1cca121de","id":"markdown_it.rules_inline.newline","ignore_all":true,"interface_hash":"7a54f4b86b119f675e3e4814faf7a64a7d486b57","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_inline/newline.py","plugin_data":null,"size":1297,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/state_inline.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/state_inline.data.json new file mode 100644 index 0000000000000000000000000000000000000000..dc2ab6ef74885fc76c4e26707b810a11fc8433f4 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/state_inline.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_inline.state_inline","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"Delimiter":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"markdown_it.rules_inline.state_inline.Delimiter","name":"Delimiter","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"markdown_it.rules_inline.state_inline.Delimiter","has_param_spec_type":false,"metaclass_type":null,"metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":19,"name":"marker","type":"builtins.int"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":22,"name":"length","type":"builtins.int"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":25,"name":"token","type":"builtins.int"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":29,"name":"end","type":"builtins.int"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":33,"name":"open","type":"builtins.bool"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":34,"name":"close","type":"builtins.bool"},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":36,"name":"level","type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}}],"frozen":false},"dataclass_tag":{}},"module_name":"markdown_it.rules_inline.state_inline","mro":["markdown_it.rules_inline.state_inline.Delimiter","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"markdown_it.rules_inline.state_inline.Delimiter.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"dataclasses.Field"}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0,0,0,1],"arg_names":["self","marker","length","token","end","open","close","level"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_inline.state_inline.Delimiter.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,0,1],"arg_names":["self","marker","length","token","end","open","close","level"],"arg_types":["markdown_it.rules_inline.state_inline.Delimiter","builtins.int","builtins.int","builtins.int","builtins.int","builtins.bool","builtins.bool",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of Delimiter","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5,5],"arg_names":["marker","length","token","end","open","close","level"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"markdown_it.rules_inline.state_inline.Delimiter.__mypy-replace","name":"__mypy-replace","original_first_arg":"marker","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5],"arg_names":["marker","length","token","end","open","close","level"],"arg_types":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.bool","builtins.bool",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of Delimiter","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"markdown_it.rules_inline.state_inline.Delimiter.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5],"arg_names":["marker","length","token","end","open","close","level"],"arg_types":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.bool","builtins.bool",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of Delimiter","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"close":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"markdown_it.rules_inline.state_inline.Delimiter.close","name":"close","setter_type":null,"type":"builtins.bool"}},"end":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"markdown_it.rules_inline.state_inline.Delimiter.end","name":"end","setter_type":null,"type":"builtins.int"}},"length":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"markdown_it.rules_inline.state_inline.Delimiter.length","name":"length","setter_type":null,"type":"builtins.int"}},"level":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"markdown_it.rules_inline.state_inline.Delimiter.level","name":"level","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"marker":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"markdown_it.rules_inline.state_inline.Delimiter.marker","name":"marker","setter_type":null,"type":"builtins.int"}},"open":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"markdown_it.rules_inline.state_inline.Delimiter.open","name":"open","setter_type":null,"type":"builtins.bool"}},"token":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"markdown_it.rules_inline.state_inline.Delimiter.token","name":"token","setter_type":null,"type":"builtins.int"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"markdown_it.rules_inline.state_inline.Delimiter.Self","id":0,"name":"Self","namespace":"","upper_bound":"markdown_it.rules_inline.state_inline.Delimiter","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"EnvType":{".class":"SymbolTableNode","cross_ref":"markdown_it.utils.EnvType","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"MarkdownIt":{".class":"SymbolTableNode","cross_ref":"markdown_it.main.MarkdownIt","kind":"Gdef"},"Scanned":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"markdown_it.rules_inline.state_inline.Scanned","name":"Scanned","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_named_tuple"],"fullname":"markdown_it.rules_inline.state_inline.Scanned","has_param_spec_type":false,"metaclass_type":null,"metadata":{"namedtuple":{"fields":["can_open","can_close","length"]}},"module_name":"markdown_it.rules_inline.state_inline","mro":["markdown_it.rules_inline.state_inline.Scanned","builtins.tuple","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","_NT":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"markdown_it.rules_inline.state_inline.Scanned._NT","name":"_NT","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},"__annotations__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"markdown_it.rules_inline.state_inline.Scanned.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"markdown_it.rules_inline.state_inline.Scanned.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__new__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["_cls","can_open","can_close","length"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static"],"fullname":"markdown_it.rules_inline.state_inline.Scanned.__new__","name":"__new__","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["_cls","can_open","can_close","length"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"markdown_it.rules_inline.state_inline.Scanned._NT","id":-1,"name":"_NT","namespace":"markdown_it.rules_inline.state_inline.Scanned.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of Scanned","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"markdown_it.rules_inline.state_inline.Scanned._NT","id":-1,"name":"_NT","namespace":"markdown_it.rules_inline.state_inline.Scanned.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"markdown_it.rules_inline.state_inline.Scanned._NT","id":-1,"name":"_NT","namespace":"markdown_it.rules_inline.state_inline.Scanned.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_asdict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["_self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_inline.state_inline.Scanned._asdict","name":"_asdict","original_first_arg":"_self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["_self"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"markdown_it.rules_inline.state_inline.Scanned._NT","id":-1,"name":"_NT","namespace":"markdown_it.rules_inline.state_inline.Scanned._asdict","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_asdict of Scanned","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"markdown_it.rules_inline.state_inline.Scanned._NT","id":-1,"name":"_NT","namespace":"markdown_it.rules_inline.state_inline.Scanned._asdict","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_field_defaults":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"markdown_it.rules_inline.state_inline.Scanned._field_defaults","name":"_field_defaults","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_field_types":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"markdown_it.rules_inline.state_inline.Scanned._field_types","name":"_field_types","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_fields":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"markdown_it.rules_inline.state_inline.Scanned._fields","name":"_fields","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_make":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["_cls","iterable"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated"],"fullname":"markdown_it.rules_inline.state_inline.Scanned._make","name":"_make","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["_cls","iterable"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"markdown_it.rules_inline.state_inline.Scanned._NT","id":-1,"name":"_NT","namespace":"markdown_it.rules_inline.state_inline.Scanned._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_make of Scanned","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"markdown_it.rules_inline.state_inline.Scanned._NT","id":-1,"name":"_NT","namespace":"markdown_it.rules_inline.state_inline.Scanned._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"markdown_it.rules_inline.state_inline.Scanned._NT","id":-1,"name":"_NT","namespace":"markdown_it.rules_inline.state_inline.Scanned._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_classmethod","is_ready"],"fullname":"markdown_it.rules_inline.state_inline.Scanned._make","name":"_make","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["_cls","iterable"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"markdown_it.rules_inline.state_inline.Scanned._NT","id":-1,"name":"_NT","namespace":"markdown_it.rules_inline.state_inline.Scanned._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_make of Scanned","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"markdown_it.rules_inline.state_inline.Scanned._NT","id":-1,"name":"_NT","namespace":"markdown_it.rules_inline.state_inline.Scanned._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"markdown_it.rules_inline.state_inline.Scanned._NT","id":-1,"name":"_NT","namespace":"markdown_it.rules_inline.state_inline.Scanned._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}}},"plugin_generated":true},"_replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5],"arg_names":["_self","can_open","can_close","length"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_inline.state_inline.Scanned._replace","name":"_replace","original_first_arg":"_self","type":{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":["_self","can_open","can_close","length"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"markdown_it.rules_inline.state_inline.Scanned._NT","id":-1,"name":"_NT","namespace":"markdown_it.rules_inline.state_inline.Scanned._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_replace of Scanned","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"markdown_it.rules_inline.state_inline.Scanned._NT","id":-1,"name":"_NT","namespace":"markdown_it.rules_inline.state_inline.Scanned._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"markdown_it.rules_inline.state_inline.Scanned._NT","id":-1,"name":"_NT","namespace":"markdown_it.rules_inline.state_inline.Scanned._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_source":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"markdown_it.rules_inline.state_inline.Scanned._source","name":"_source","setter_type":null,"type":"builtins.str"}},"can_close":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"markdown_it.rules_inline.state_inline.Scanned.can_close","name":"can_close","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}}},"can_open":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"markdown_it.rules_inline.state_inline.Scanned.can_open","name":"can_open","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}}},"length":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"markdown_it.rules_inline.state_inline.Scanned.length","name":"length","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}}}},"self_type":null,"slots":null,"tuple_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_vars":[],"typeddict_type":null}},"StateBase":{".class":"SymbolTableNode","cross_ref":"markdown_it.ruler.StateBase","kind":"Gdef"},"StateInline":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["markdown_it.ruler.StateBase"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"markdown_it.rules_inline.state_inline.StateInline","name":"StateInline","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"markdown_it.rules_inline.state_inline.StateInline","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"markdown_it.rules_inline.state_inline","mro":["markdown_it.rules_inline.state_inline.StateInline","markdown_it.ruler.StateBase","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0],"arg_names":["self","src","md","env","outTokens"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"markdown_it.rules_inline.state_inline.StateInline.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":["self","src","md","env","outTokens"],"arg_types":["markdown_it.rules_inline.state_inline.StateInline","builtins.str","markdown_it.main.MarkdownIt",{".class":"TypeAliasType","args":[],"type_ref":"markdown_it.utils.EnvType"},{".class":"Instance","args":["markdown_it.token.Token"],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of StateInline","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"markdown_it.rules_inline.state_inline.StateInline.__repr__","name":"__repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["markdown_it.rules_inline.state_inline.StateInline"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr__ of StateInline","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prev_delimiters":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"markdown_it.rules_inline.state_inline.StateInline._prev_delimiters","name":"_prev_delimiters","setter_type":null,"type":{".class":"Instance","args":[{".class":"Instance","args":["markdown_it.rules_inline.state_inline.Delimiter"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"builtins.list"}}},"backticks":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"markdown_it.rules_inline.state_inline.StateInline.backticks","name":"backticks","setter_type":null,"type":{".class":"Instance","args":["builtins.int","builtins.int"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"backticksScanned":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"markdown_it.rules_inline.state_inline.StateInline.backticksScanned","name":"backticksScanned","setter_type":null,"type":"builtins.bool"}},"cache":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"markdown_it.rules_inline.state_inline.StateInline.cache","name":"cache","setter_type":null,"type":{".class":"Instance","args":["builtins.int","builtins.int"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"delimiters":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"markdown_it.rules_inline.state_inline.StateInline.delimiters","name":"delimiters","setter_type":null,"type":{".class":"Instance","args":["markdown_it.rules_inline.state_inline.Delimiter"],"extra_attrs":null,"type_ref":"builtins.list"}}},"level":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"markdown_it.rules_inline.state_inline.StateInline.level","name":"level","setter_type":null,"type":"builtins.int"}},"linkLevel":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"markdown_it.rules_inline.state_inline.StateInline.linkLevel","name":"linkLevel","setter_type":null,"type":"builtins.int"}},"pending":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"markdown_it.rules_inline.state_inline.StateInline.pending","name":"pending","setter_type":null,"type":"builtins.str"}},"pendingLevel":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"markdown_it.rules_inline.state_inline.StateInline.pendingLevel","name":"pendingLevel","setter_type":null,"type":"builtins.int"}},"pos":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"markdown_it.rules_inline.state_inline.StateInline.pos","name":"pos","setter_type":null,"type":"builtins.int"}},"posMax":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"markdown_it.rules_inline.state_inline.StateInline.posMax","name":"posMax","setter_type":null,"type":"builtins.int"}},"push":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","ttype","tag","nesting"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"markdown_it.rules_inline.state_inline.StateInline.push","name":"push","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","ttype","tag","nesting"],"arg_types":["markdown_it.rules_inline.state_inline.StateInline","builtins.str","builtins.str",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.int","value":-1},{".class":"LiteralType","fallback":"builtins.int","value":0},{".class":"LiteralType","fallback":"builtins.int","value":1}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"push of StateInline","ret_type":"markdown_it.token.Token","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"pushPending":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"markdown_it.rules_inline.state_inline.StateInline.pushPending","name":"pushPending","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["markdown_it.rules_inline.state_inline.StateInline"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pushPending of StateInline","ret_type":"markdown_it.token.Token","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"scanDelims":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","start","canSplitWord"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"markdown_it.rules_inline.state_inline.StateInline.scanDelims","name":"scanDelims","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","start","canSplitWord"],"arg_types":["markdown_it.rules_inline.state_inline.StateInline","builtins.int","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"scanDelims of StateInline","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"markdown_it.rules_inline.state_inline.Scanned"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"tokens":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"markdown_it.rules_inline.state_inline.StateInline.tokens","name":"tokens","setter_type":null,"type":{".class":"Instance","args":["markdown_it.token.Token"],"extra_attrs":null,"type_ref":"builtins.list"}}},"tokens_meta":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"markdown_it.rules_inline.state_inline.StateInline.tokens_meta","name":"tokens_meta","setter_type":null,"type":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.list"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"markdown_it.rules_inline.state_inline.StateInline.Self","id":0,"name":"Self","namespace":"","upper_bound":"markdown_it.rules_inline.state_inline.StateInline","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"Token":{".class":"SymbolTableNode","cross_ref":"markdown_it.token.Token","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.state_inline.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.state_inline.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.state_inline.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.state_inline.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.state_inline.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.state_inline.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"dataclass":{".class":"SymbolTableNode","cross_ref":"dataclasses.dataclass","kind":"Gdef"},"isMdAsciiPunct":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.utils.isMdAsciiPunct","kind":"Gdef"},"isPunctChar":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.utils.isPunctChar","kind":"Gdef"},"isWhiteSpace":{".class":"SymbolTableNode","cross_ref":"markdown_it.common.utils.isWhiteSpace","kind":"Gdef"},"namedtuple":{".class":"SymbolTableNode","cross_ref":"collections.namedtuple","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_inline/state_inline.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/state_inline.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/state_inline.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..53b32d2f019be7a1087c7811ea0e8ce637d5ebd8 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/state_inline.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[7,8,9,10,1,3,4,5,13,1,1,1,1],"dep_prios":[5,5,5,5,5,5,5,5,25,5,30,30,30],"dependencies":["markdown_it.common.utils","markdown_it.ruler","markdown_it.token","markdown_it.utils","__future__","collections","dataclasses","typing","markdown_it","builtins","_frozen_importlib","abc","markdown_it.main"],"hash":"d1745360012b2b6c27726de5cafe07c697fb454c","id":"markdown_it.rules_inline.state_inline","ignore_all":true,"interface_hash":"c0acfb3490e7e9c9f1d94c95dbd1133aa3a89edb","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_inline/state_inline.py","plugin_data":null,"size":5003,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/strikethrough.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/strikethrough.data.json new file mode 100644 index 0000000000000000000000000000000000000000..12411f8824ed85ae6cb9280152417bd2ca6cc267 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/strikethrough.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_inline.strikethrough","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Delimiter":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_inline.state_inline.Delimiter","kind":"Gdef"},"StateInline":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_inline.state_inline.StateInline","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.strikethrough.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.strikethrough.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.strikethrough.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.strikethrough.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.strikethrough.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.strikethrough.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_postProcess":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["state","delimiters"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_inline.strikethrough._postProcess","name":"_postProcess","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["state","delimiters"],"arg_types":["markdown_it.rules_inline.state_inline.StateInline",{".class":"Instance","args":["markdown_it.rules_inline.state_inline.Delimiter"],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_postProcess","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"postProcess":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["state"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_inline.strikethrough.postProcess","name":"postProcess","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["state"],"arg_types":["markdown_it.rules_inline.state_inline.StateInline"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"postProcess","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"tokenize":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["state","silent"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_inline.strikethrough.tokenize","name":"tokenize","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["state","silent"],"arg_types":["markdown_it.rules_inline.state_inline.StateInline","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tokenize","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_inline/strikethrough.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/strikethrough.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/strikethrough.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..9b04542ad6d8412ee08dd860c29e743cf2fc61bc --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/strikethrough.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[4,2,1,1,1,1,1],"dep_prios":[5,5,5,30,30,30,30],"dependencies":["markdown_it.rules_inline.state_inline","__future__","builtins","_frozen_importlib","abc","markdown_it.ruler","typing"],"hash":"11d144ec03962f43571b596a038e546e3b4ad541","id":"markdown_it.rules_inline.strikethrough","ignore_all":true,"interface_hash":"9fde8c836203861cb0af221a29e7fb7d0915a11d","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_inline/strikethrough.py","plugin_data":null,"size":3214,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/text.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/text.data.json new file mode 100644 index 0000000000000000000000000000000000000000..0e02c7ffffd1b4f3e592ccf86c7544c974933044 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/text.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"markdown_it.rules_inline.text","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","StateInline":{".class":"SymbolTableNode","cross_ref":"markdown_it.rules_inline.state_inline.StateInline","kind":"Gdef"},"_TerminatorChars":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"markdown_it.rules_inline.text._TerminatorChars","name":"_TerminatorChars","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.text.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.text.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.text.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.text.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.text.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"markdown_it.rules_inline.text.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_terminator_char_regex":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated"],"fullname":"markdown_it.rules_inline.text._terminator_char_regex","name":"_terminator_char_regex","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_terminator_char_regex","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"markdown_it.rules_inline.text._terminator_char_regex","name":"_terminator_char_regex","setter_type":null,"type":{".class":"Instance","args":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}],"extra_attrs":null,"type_ref":"functools._lru_cache_wrapper"}}}},"functools":{".class":"SymbolTableNode","cross_ref":"functools","kind":"Gdef"},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef"},"text":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["state","silent"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"markdown_it.rules_inline.text.text","name":"text","original_first_arg":"state","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["state","silent"],"arg_types":["markdown_it.rules_inline.state_inline.StateInline","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"text","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_inline/text.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/text.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/text.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..287f074a6f3db3ef46424fd072f08bebc632f194 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/markdown_it/rules_inline/text.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[6,1,2,1,1,1,1,1],"dep_prios":[5,10,10,5,30,30,30,30],"dependencies":["markdown_it.rules_inline.state_inline","functools","re","builtins","_frozen_importlib","abc","markdown_it.ruler","typing"],"hash":"8bbd5d4c3cb83886dde7312057c1139be59cd515","id":"markdown_it.rules_inline.text","ignore_all":true,"interface_hash":"0190b0f6e81ef63b7137894ee8909790b503b8bb","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/markdown_it/rules_inline/text.py","plugin_data":null,"size":1119,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..8a9d3d633bfcbdea10a19a2134bf7333247045a7 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy._core","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_core/__init__.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..30718b9c32bfa28ac6a628c58167b165217e4b55 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106713,"dep_lines":[1,1,1,1],"dep_prios":[5,30,30,30],"dependencies":["builtins","_frozen_importlib","abc","typing"],"hash":"56be4cdb58c33a6b9e2f7d295a11b8c420249e8b","id":"numpy._core","ignore_all":true,"interface_hash":"288b71f4681cea3620b7c97b8c72ea4af1229cc9","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_core/__init__.pyi","plugin_data":null,"size":86,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/_asarray.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/_asarray.data.json new file mode 100644 index 0000000000000000000000000000000000000000..464b6e14d3ca6265f1d5346072bf51e0a2a92298 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/_asarray.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy._core._asarray","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"DTypeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like.DTypeLike","kind":"Gdef","module_hidden":true,"module_public":false},"Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef","module_hidden":true,"module_public":false},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy._core._asarray.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core._asarray.TypeAlias","source_any":null,"type_of_any":3}}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._asarray._ArrayT","name":"_ArrayT","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}},"_E":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._core._asarray._E","name":"_E","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core._asarray.TypeAlias","source_any":null,"type_of_any":3}}},"_Requirements":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._core._asarray._Requirements","name":"_Requirements","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core._asarray.TypeAlias","source_any":null,"type_of_any":3}}},"_RequirementsWithE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._core._asarray._RequirementsWithE","name":"_RequirementsWithE","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core._asarray.TypeAlias","source_any":null,"type_of_any":3}}},"_SupportsArrayFunc":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._SupportsArrayFunc","kind":"Gdef","module_hidden":true,"module_public":false},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core._asarray.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core._asarray.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core._asarray.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core._asarray.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core._asarray.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core._asarray.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false},"require":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core._asarray.require","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,5],"arg_names":["a","dtype","requirements","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core._asarray.require","name":"require","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["a","dtype","requirements","like"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._asarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core._asarray.require#0","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core._asarray.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._core._asarray.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},"numpy._typing._array_like._SupportsArrayFunc"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"require","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._asarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core._asarray.require#0","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._asarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core._asarray.require#0","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core._asarray.require","name":"require","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["a","dtype","requirements","like"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._asarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core._asarray.require#0","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core._asarray.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._core._asarray.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},"numpy._typing._array_like._SupportsArrayFunc"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"require","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._asarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core._asarray.require#0","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._asarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core._asarray.require#0","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,5],"arg_names":["a","dtype","requirements","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core._asarray.require","name":"require","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["a","dtype","requirements","like"],"arg_types":["builtins.object",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core._asarray.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._core._asarray.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"uses_pep604_syntax":true},"numpy._typing._array_like._SupportsArrayFunc"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"require","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core._asarray.require","name":"require","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["a","dtype","requirements","like"],"arg_types":["builtins.object",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core._asarray.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._core._asarray.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"uses_pep604_syntax":true},"numpy._typing._array_like._SupportsArrayFunc"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"require","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,5],"arg_names":["a","dtype","requirements","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core._asarray.require","name":"require","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["a","dtype","requirements","like"],"arg_types":["builtins.object",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core._asarray.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._core._asarray.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},"numpy._typing._array_like._SupportsArrayFunc"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"require","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core._asarray.require","name":"require","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["a","dtype","requirements","like"],"arg_types":["builtins.object",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core._asarray.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._core._asarray.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},"numpy._typing._array_like._SupportsArrayFunc"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"require","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["a","dtype","requirements","like"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._asarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core._asarray.require#0","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core._asarray.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._core._asarray.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},"numpy._typing._array_like._SupportsArrayFunc"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"require","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._asarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core._asarray.require#0","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._asarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core._asarray.require#0","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["a","dtype","requirements","like"],"arg_types":["builtins.object",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core._asarray.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._core._asarray.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"uses_pep604_syntax":true},"numpy._typing._array_like._SupportsArrayFunc"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"require","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["a","dtype","requirements","like"],"arg_types":["builtins.object",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core._asarray.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._core._asarray.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},"numpy._typing._array_like._SupportsArrayFunc"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"require","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_core/_asarray.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/_asarray.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/_asarray.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..51630c4a8d9ba40ffee36ef83b972357a733f415 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/_asarray.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,4,2,1,1,1,1],"dep_prios":[5,5,5,5,30,30,30],"dependencies":["collections.abc","numpy._typing","typing","builtins","_frozen_importlib","abc","numpy._typing._array_like"],"hash":"5cefdb672ae333e696bcbf4ae096232378f99575","id":"numpy._core._asarray","ignore_all":true,"interface_hash":"9ae19c7d9c25fca8ef9a9cfebc4becbd61eb4533","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_core/_asarray.pyi","plugin_data":null,"size":1073,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/_internal.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/_internal.data.json new file mode 100644 index 0000000000000000000000000000000000000000..2827c6fb748b19fe8c9eebf94771882d690c1833 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/_internal.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy._core._internal","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef","module_hidden":true,"module_public":false},"Final":{".class":"SymbolTableNode","cross_ref":"typing.Final","kind":"Gdef","module_hidden":true,"module_public":false},"Generic":{".class":"SymbolTableNode","cross_ref":"typing.Generic","kind":"Gdef","module_hidden":true,"module_public":false},"IS_PYPY":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy._core._internal.IS_PYPY","name":"IS_PYPY","setter_type":null,"type":"builtins.bool"}},"Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef","module_hidden":true,"module_public":false},"Self":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy._core._internal.Self","name":"Self","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core._internal.Self","source_any":null,"type_of_any":3}}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing_extensions.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"_CT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._internal._CT","name":"_CT","upper_bound":"_ctypes._CData","values":[],"variance":0}},"_CastT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._internal._CastT","name":"_CastT","upper_bound":"_ctypes._CanCastTo","values":[],"variance":0}},"_PT_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"NoneType"},"fullname":"numpy._core._internal._PT_co","name":"_PT_co","upper_bound":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}},"_T_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._internal._T_co","name":"_T_co","upper_bound":"builtins.object","values":[],"variance":1}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core._internal.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core._internal.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core._internal.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core._internal.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core._internal.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core._internal.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_ctypes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._core._internal._ctypes","name":"_ctypes","type_vars":[{".class":"TypeVarType","default":{".class":"NoneType"},"fullname":"numpy._core._internal._PT_co","id":1,"name":"_PT_co","namespace":"numpy._core._internal._ctypes","upper_bound":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy._core._internal._ctypes","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._core._internal","mro":["numpy._core._internal._ctypes","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core._internal._ctypes.__init__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":[null,"array","ptr"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core._internal._ctypes.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":[null,"array","ptr"],"arg_types":[{".class":"Instance","args":[{".class":"NoneType"}],"extra_attrs":null,"type_ref":"numpy._core._internal._ctypes"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of _ctypes","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core._internal._ctypes.__init__","name":"__init__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":[null,"array","ptr"],"arg_types":[{".class":"Instance","args":[{".class":"NoneType"}],"extra_attrs":null,"type_ref":"numpy._core._internal._ctypes"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of _ctypes","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":[null,"array","ptr"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._core._internal._ctypes.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"array","ptr"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"NoneType"},"fullname":"numpy._core._internal._PT_co","id":1,"name":"_PT_co","namespace":"numpy._core._internal._ctypes","upper_bound":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core._internal._ctypes"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"NoneType"},"fullname":"numpy._core._internal._PT_co","id":1,"name":"_PT_co","namespace":"numpy._core._internal._ctypes","upper_bound":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of _ctypes","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core._internal._ctypes.__init__","name":"__init__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"array","ptr"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"NoneType"},"fullname":"numpy._core._internal._PT_co","id":1,"name":"_PT_co","namespace":"numpy._core._internal._ctypes","upper_bound":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core._internal._ctypes"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"NoneType"},"fullname":"numpy._core._internal._PT_co","id":1,"name":"_PT_co","namespace":"numpy._core._internal._ctypes","upper_bound":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of _ctypes","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":[null,"array","ptr"],"arg_types":[{".class":"Instance","args":[{".class":"NoneType"}],"extra_attrs":null,"type_ref":"numpy._core._internal._ctypes"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of _ctypes","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"array","ptr"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"NoneType"},"fullname":"numpy._core._internal._PT_co","id":1,"name":"_PT_co","namespace":"numpy._core._internal._ctypes","upper_bound":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core._internal._ctypes"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"NoneType"},"fullname":"numpy._core._internal._PT_co","id":1,"name":"_PT_co","namespace":"numpy._core._internal._ctypes","upper_bound":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of _ctypes","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"_as_parameter_":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._core._internal._ctypes._as_parameter_","name":"_as_parameter_","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"NoneType"},"fullname":"numpy._core._internal._PT_co","id":1,"name":"_PT_co","namespace":"numpy._core._internal._ctypes","upper_bound":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core._internal._ctypes"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_as_parameter_ of _ctypes","ret_type":"ctypes.c_void_p","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._core._internal._ctypes._as_parameter_","name":"_as_parameter_","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"NoneType"},"fullname":"numpy._core._internal._PT_co","id":1,"name":"_PT_co","namespace":"numpy._core._internal._ctypes","upper_bound":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core._internal._ctypes"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_as_parameter_ of _ctypes","ret_type":"ctypes.c_void_p","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"data":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._core._internal._ctypes.data","name":"data","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"NoneType"},"fullname":"numpy._core._internal._PT_co","id":1,"name":"_PT_co","namespace":"numpy._core._internal._ctypes","upper_bound":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core._internal._ctypes"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"data of _ctypes","ret_type":{".class":"TypeVarType","default":{".class":"NoneType"},"fullname":"numpy._core._internal._PT_co","id":1,"name":"_PT_co","namespace":"numpy._core._internal._ctypes","upper_bound":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._core._internal._ctypes.data","name":"data","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"NoneType"},"fullname":"numpy._core._internal._PT_co","id":1,"name":"_PT_co","namespace":"numpy._core._internal._ctypes","upper_bound":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core._internal._ctypes"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"data of _ctypes","ret_type":{".class":"TypeVarType","default":{".class":"NoneType"},"fullname":"numpy._core._internal._PT_co","id":1,"name":"_PT_co","namespace":"numpy._core._internal._ctypes","upper_bound":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"data_as":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core._internal._ctypes.data_as","name":"data_as","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"obj"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"NoneType"},"fullname":"numpy._core._internal._PT_co","id":1,"name":"_PT_co","namespace":"numpy._core._internal._ctypes","upper_bound":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core._internal._ctypes"},{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._internal._CastT","id":-1,"name":"_CastT","namespace":"numpy._core._internal._ctypes.data_as","upper_bound":"_ctypes._CanCastTo","values":[],"variance":0}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"data_as of _ctypes","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._internal._CastT","id":-1,"name":"_CastT","namespace":"numpy._core._internal._ctypes.data_as","upper_bound":"_ctypes._CanCastTo","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._internal._CastT","id":-1,"name":"_CastT","namespace":"numpy._core._internal._ctypes.data_as","upper_bound":"_ctypes._CanCastTo","values":[],"variance":0}]}}},"get_as_parameter":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":"function numpy._core._internal._ctypes.get_as_parameter is deprecated: \"get_as_parameter\" is deprecated. Use \"_as_parameter_\" instead","flags":["is_decorated","is_trivial_self"],"fullname":"numpy._core._internal._ctypes.get_as_parameter","name":"get_as_parameter","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"NoneType"},"fullname":"numpy._core._internal._PT_co","id":1,"name":"_PT_co","namespace":"numpy._core._internal._ctypes","upper_bound":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core._internal._ctypes"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_as_parameter of _ctypes","ret_type":"ctypes.c_void_p","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred"],"fullname":"numpy._core._internal._ctypes.get_as_parameter","name":"get_as_parameter","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"NoneType"},"fullname":"numpy._core._internal._PT_co","id":1,"name":"_PT_co","namespace":"numpy._core._internal._ctypes","upper_bound":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core._internal._ctypes"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_as_parameter of _ctypes","ret_type":"ctypes.c_void_p","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"get_data":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":"function numpy._core._internal._ctypes.get_data is deprecated: \"get_data\" is deprecated. Use \"data\" instead","flags":["is_decorated","is_trivial_self"],"fullname":"numpy._core._internal._ctypes.get_data","name":"get_data","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"NoneType"},"fullname":"numpy._core._internal._PT_co","id":1,"name":"_PT_co","namespace":"numpy._core._internal._ctypes","upper_bound":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core._internal._ctypes"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_data of _ctypes","ret_type":{".class":"TypeVarType","default":{".class":"NoneType"},"fullname":"numpy._core._internal._PT_co","id":1,"name":"_PT_co","namespace":"numpy._core._internal._ctypes","upper_bound":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred"],"fullname":"numpy._core._internal._ctypes.get_data","name":"get_data","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"NoneType"},"fullname":"numpy._core._internal._PT_co","id":1,"name":"_PT_co","namespace":"numpy._core._internal._ctypes","upper_bound":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core._internal._ctypes"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_data of _ctypes","ret_type":{".class":"TypeVarType","default":{".class":"NoneType"},"fullname":"numpy._core._internal._PT_co","id":1,"name":"_PT_co","namespace":"numpy._core._internal._ctypes","upper_bound":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"get_shape":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":"function numpy._core._internal._ctypes.get_shape is deprecated: \"get_shape\" is deprecated. Use \"shape\" instead","flags":["is_decorated","is_trivial_self"],"fullname":"numpy._core._internal._ctypes.get_shape","name":"get_shape","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"NoneType"},"fullname":"numpy._core._internal._PT_co","id":1,"name":"_PT_co","namespace":"numpy._core._internal._ctypes","upper_bound":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core._internal._ctypes"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_shape of _ctypes","ret_type":{".class":"Instance","args":["ctypes.c_int64"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred"],"fullname":"numpy._core._internal._ctypes.get_shape","name":"get_shape","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"NoneType"},"fullname":"numpy._core._internal._PT_co","id":1,"name":"_PT_co","namespace":"numpy._core._internal._ctypes","upper_bound":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core._internal._ctypes"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_shape of _ctypes","ret_type":{".class":"Instance","args":["ctypes.c_int64"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"get_strides":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":"function numpy._core._internal._ctypes.get_strides is deprecated: \"get_strides\" is deprecated. Use \"strides\" instead","flags":["is_decorated","is_trivial_self"],"fullname":"numpy._core._internal._ctypes.get_strides","name":"get_strides","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"NoneType"},"fullname":"numpy._core._internal._PT_co","id":1,"name":"_PT_co","namespace":"numpy._core._internal._ctypes","upper_bound":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core._internal._ctypes"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_strides of _ctypes","ret_type":{".class":"Instance","args":["ctypes.c_int64"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred"],"fullname":"numpy._core._internal._ctypes.get_strides","name":"get_strides","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"NoneType"},"fullname":"numpy._core._internal._PT_co","id":1,"name":"_PT_co","namespace":"numpy._core._internal._ctypes","upper_bound":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core._internal._ctypes"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_strides of _ctypes","ret_type":{".class":"Instance","args":["ctypes.c_int64"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"shape":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._core._internal._ctypes.shape","name":"shape","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"NoneType"},"fullname":"numpy._core._internal._PT_co","id":1,"name":"_PT_co","namespace":"numpy._core._internal._ctypes","upper_bound":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core._internal._ctypes"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shape of _ctypes","ret_type":{".class":"Instance","args":["ctypes.c_int64"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._core._internal._ctypes.shape","name":"shape","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"NoneType"},"fullname":"numpy._core._internal._PT_co","id":1,"name":"_PT_co","namespace":"numpy._core._internal._ctypes","upper_bound":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core._internal._ctypes"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shape of _ctypes","ret_type":{".class":"Instance","args":["ctypes.c_int64"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"shape_as":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core._internal._ctypes.shape_as","name":"shape_as","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"obj"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"NoneType"},"fullname":"numpy._core._internal._PT_co","id":1,"name":"_PT_co","namespace":"numpy._core._internal._ctypes","upper_bound":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core._internal._ctypes"},{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._internal._CT","id":-1,"name":"_CT","namespace":"numpy._core._internal._ctypes.shape_as","upper_bound":"_ctypes._CData","values":[],"variance":0}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shape_as of _ctypes","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._internal._CT","id":-1,"name":"_CT","namespace":"numpy._core._internal._ctypes.shape_as","upper_bound":"_ctypes._CData","values":[],"variance":0}],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._internal._CT","id":-1,"name":"_CT","namespace":"numpy._core._internal._ctypes.shape_as","upper_bound":"_ctypes._CData","values":[],"variance":0}]}}},"strides":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._core._internal._ctypes.strides","name":"strides","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"NoneType"},"fullname":"numpy._core._internal._PT_co","id":1,"name":"_PT_co","namespace":"numpy._core._internal._ctypes","upper_bound":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core._internal._ctypes"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strides of _ctypes","ret_type":{".class":"Instance","args":["ctypes.c_int64"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._core._internal._ctypes.strides","name":"strides","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"NoneType"},"fullname":"numpy._core._internal._PT_co","id":1,"name":"_PT_co","namespace":"numpy._core._internal._ctypes","upper_bound":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core._internal._ctypes"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strides of _ctypes","ret_type":{".class":"Instance","args":["ctypes.c_int64"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"strides_as":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core._internal._ctypes.strides_as","name":"strides_as","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"obj"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"NoneType"},"fullname":"numpy._core._internal._PT_co","id":1,"name":"_PT_co","namespace":"numpy._core._internal._ctypes","upper_bound":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core._internal._ctypes"},{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._internal._CT","id":-1,"name":"_CT","namespace":"numpy._core._internal._ctypes.strides_as","upper_bound":"_ctypes._CData","values":[],"variance":0}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strides_as of _ctypes","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._internal._CT","id":-1,"name":"_CT","namespace":"numpy._core._internal._ctypes.strides_as","upper_bound":"_ctypes._CData","values":[],"variance":0}],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._internal._CT","id":-1,"name":"_CT","namespace":"numpy._core._internal._ctypes.strides_as","upper_bound":"_ctypes._CData","values":[],"variance":0}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._internal._ctypes.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"NoneType"},"fullname":"numpy._core._internal._PT_co","id":1,"name":"_PT_co","namespace":"numpy._core._internal._ctypes","upper_bound":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core._internal._ctypes"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_PT_co"],"typeddict_type":null}},"array_function_errmsg_formatter":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["public_api","types"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core._internal.array_function_errmsg_formatter","name":"array_function_errmsg_formatter","original_first_arg":"public_api","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["public_api","types"],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":"builtins.object","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array_function_errmsg_formatter","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"array_ufunc_errmsg_formatter":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,2,4],"arg_names":["dummy","ufunc","method","inputs","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core._internal.array_ufunc_errmsg_formatter","name":"array_ufunc_errmsg_formatter","original_first_arg":"dummy","type":{".class":"CallableType","arg_kinds":[0,0,0,2,4],"arg_names":["dummy","ufunc","method","inputs","kwargs"],"arg_types":["builtins.object","numpy.ufunc","builtins.str","builtins.object","builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array_ufunc_errmsg_formatter","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"c_intp":{".class":"SymbolTableNode","cross_ref":"numpy.ctypeslib._ctypeslib.c_intp","kind":"Gdef","module_hidden":true,"module_public":false},"ct":{".class":"SymbolTableNode","cross_ref":"ctypes","kind":"Gdef","module_hidden":true,"module_public":false},"deprecated":{".class":"SymbolTableNode","cross_ref":"typing_extensions.deprecated","kind":"Gdef","module_hidden":true,"module_public":false},"dummy_ctype":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._core._internal.dummy_ctype","name":"dummy_ctype","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._internal._T_co","id":1,"name":"_T_co","namespace":"numpy._core._internal.dummy_ctype","upper_bound":"builtins.object","values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy._core._internal.dummy_ctype","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._core._internal","mro":["numpy._core._internal.dummy_ctype","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2],"arg_names":[null,"other"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core._internal.dummy_ctype.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2],"arg_names":[null,"other"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._internal._T_co","id":1,"name":"_T_co","namespace":"numpy._core._internal.dummy_ctype","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core._internal.dummy_ctype"},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of dummy_ctype","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._internal._T_co","id":1,"name":"_T_co","namespace":"numpy._core._internal.dummy_ctype","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__eq__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core._internal.dummy_ctype.__eq__","name":"__eq__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._internal._T_co","id":1,"name":"_T_co","namespace":"numpy._core._internal.dummy_ctype","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core._internal.dummy_ctype"},{".class":"AnyType","missing_import_name":"numpy._core._internal.Self","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__eq__ of dummy_ctype","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core._internal.dummy_ctype.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"cls"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._internal._T_co","id":1,"name":"_T_co","namespace":"numpy._core._internal.dummy_ctype","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core._internal.dummy_ctype"},{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._internal._T_co","id":1,"name":"_T_co","namespace":"numpy._core._internal.dummy_ctype","upper_bound":"builtins.object","values":[],"variance":1}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of dummy_ctype","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__mul__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core._internal.dummy_ctype.__mul__","name":"__mul__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._internal._T_co","id":1,"name":"_T_co","namespace":"numpy._core._internal.dummy_ctype","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core._internal.dummy_ctype"},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mul__ of dummy_ctype","ret_type":{".class":"AnyType","missing_import_name":"numpy._core._internal.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__ne__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core._internal.dummy_ctype.__ne__","name":"__ne__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._internal._T_co","id":1,"name":"_T_co","namespace":"numpy._core._internal.dummy_ctype","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core._internal.dummy_ctype"},{".class":"AnyType","missing_import_name":"numpy._core._internal.Self","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ne__ of dummy_ctype","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_cls":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy._core._internal.dummy_ctype._cls","name":"_cls","setter_type":null,"type":{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._internal._T_co","id":1,"name":"_T_co","namespace":"numpy._core._internal.dummy_ctype","upper_bound":"builtins.object","values":[],"variance":1}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._internal.dummy_ctype.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._internal._T_co","id":1,"name":"_T_co","namespace":"numpy._core._internal.dummy_ctype","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core._internal.dummy_ctype"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_T_co"],"typeddict_type":null}},"format_re":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy._core._internal.format_re","name":"format_re","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"npt":{".class":"SymbolTableNode","cross_ref":"numpy.typing","kind":"Gdef","module_hidden":true,"module_public":false},"npy_ctypes_check":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core._internal.npy_ctypes_check","name":"npy_ctypes_check","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":["builtins.type"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"npy_ctypes_check","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef","module_hidden":true,"module_public":false},"sep_re":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy._core._internal.sep_re","name":"sep_re","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"space_re":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy._core._internal.space_re","name":"space_re","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_core/_internal.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/_internal.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/_internal.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..1c338e8f5a2db067f674150477d1997a57580e72 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/_internal.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[3,9,10,1,2,4,6,8,1,1,1,1],"dep_prios":[5,10,5,10,10,5,5,10,5,30,30,30],"dependencies":["collections.abc","numpy.typing","numpy.ctypeslib","ctypes","re","typing","typing_extensions","numpy","builtins","_ctypes","_frozen_importlib","abc"],"hash":"82c2afc810bfa436254406c52ee6412a8db93acc","id":"numpy._core._internal","ignore_all":true,"interface_hash":"4b6797a2720e8c11b8e9e8b238ac654b101193d7","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_core/_internal.pyi","plugin_data":null,"size":2654,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/_type_aliases.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/_type_aliases.data.json new file mode 100644 index 0000000000000000000000000000000000000000..534dccc0095e3072fb33c777aa7eb0427c9a318f --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/_type_aliases.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy._core._type_aliases","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Collection":{".class":"SymbolTableNode","cross_ref":"typing.Collection","kind":"Gdef","module_hidden":true,"module_public":false},"Final":{".class":"SymbolTableNode","cross_ref":"typing.Final","kind":"Gdef","module_hidden":true,"module_public":false},"L":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy._core._type_aliases.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core._type_aliases.TypeAlias","source_any":null,"type_of_any":3}}},"TypedDict":{".class":"SymbolTableNode","cross_ref":"typing.TypedDict","kind":"Gdef","module_hidden":true,"module_public":false},"_AbstractTypeName":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._core._type_aliases._AbstractTypeName","name":"_AbstractTypeName","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core._type_aliases.TypeAlias","source_any":null,"type_of_any":3}}},"_AliasesType":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._core._type_aliases._AliasesType","name":"_AliasesType","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy._core._type_aliases._AliasesType","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._core._type_aliases","mro":["numpy._core._type_aliases._AliasesType","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["double",{".class":"LiteralType","fallback":"builtins.str","value":"float64"}],["cdouble",{".class":"LiteralType","fallback":"builtins.str","value":"complex128"}],["single",{".class":"LiteralType","fallback":"builtins.str","value":"float32"}],["csingle",{".class":"LiteralType","fallback":"builtins.str","value":"complex64"}],["half",{".class":"LiteralType","fallback":"builtins.str","value":"float16"}],["bool_",{".class":"LiteralType","fallback":"builtins.str","value":"bool"}],["int_",{".class":"LiteralType","fallback":"builtins.str","value":"intp"}],["uint",{".class":"LiteralType","fallback":"builtins.str","value":"intp"}]],"readonly_keys":[],"required_keys":["bool_","cdouble","csingle","double","half","int_","single","uint"]}}},"_CNamesDict":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._core._type_aliases._CNamesDict","name":"_CNamesDict","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy._core._type_aliases._CNamesDict","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._core._type_aliases","mro":["numpy._core._type_aliases._CNamesDict","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["BOOL",{".class":"Instance","args":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],["HALF",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],["FLOAT",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],["DOUBLE",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],["LONGDOUBLE",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],["CFLOAT",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],["CDOUBLE",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],["CLONGDOUBLE",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],["STRING",{".class":"Instance","args":["numpy.bytes_"],"extra_attrs":null,"type_ref":"numpy.dtype"}],["UNICODE",{".class":"Instance","args":["numpy.str_"],"extra_attrs":null,"type_ref":"numpy.dtype"}],["VOID",{".class":"Instance","args":["numpy.void"],"extra_attrs":null,"type_ref":"numpy.dtype"}],["OBJECT",{".class":"Instance","args":["numpy.object_"],"extra_attrs":null,"type_ref":"numpy.dtype"}],["DATETIME",{".class":"Instance","args":[{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],["TIMEDELTA",{".class":"Instance","args":[{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],["BYTE",{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.byte"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],["UBYTE",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],["SHORT",{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.short"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],["USHORT",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],["INT",{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.intc"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],["UINT",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],["LONG",{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.long"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],["ULONG",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],["LONGLONG",{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.longlong"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],["ULONGLONG",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}]],"readonly_keys":[],"required_keys":["BOOL","BYTE","CDOUBLE","CFLOAT","CLONGDOUBLE","DATETIME","DOUBLE","FLOAT","HALF","INT","LONG","LONGDOUBLE","LONGLONG","OBJECT","SHORT","STRING","TIMEDELTA","UBYTE","UINT","ULONG","ULONGLONG","UNICODE","USHORT","VOID"]}}},"_ExtraAliasesType":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._core._type_aliases._ExtraAliasesType","name":"_ExtraAliasesType","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy._core._type_aliases._ExtraAliasesType","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._core._type_aliases","mro":["numpy._core._type_aliases._ExtraAliasesType","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["float",{".class":"LiteralType","fallback":"builtins.str","value":"float64"}],["complex",{".class":"LiteralType","fallback":"builtins.str","value":"complex128"}],["object",{".class":"LiteralType","fallback":"builtins.str","value":"object_"}],["bytes",{".class":"LiteralType","fallback":"builtins.str","value":"bytes_"}],["a",{".class":"LiteralType","fallback":"builtins.str","value":"bytes_"}],["int",{".class":"LiteralType","fallback":"builtins.str","value":"int_"}],["str",{".class":"LiteralType","fallback":"builtins.str","value":"str_"}],["unicode",{".class":"LiteralType","fallback":"builtins.str","value":"str_"}]],"readonly_keys":[],"required_keys":["a","bytes","complex","float","int","object","str","unicode"]}}},"_SCTypes":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._core._type_aliases._SCTypes","name":"_SCTypes","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy._core._type_aliases._SCTypes","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._core._type_aliases","mro":["numpy._core._type_aliases._SCTypes","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["int",{".class":"Instance","args":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.signedinteger"}}],"extra_attrs":null,"type_ref":"typing.Collection"}],["uint",{".class":"Instance","args":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.unsignedinteger"}}],"extra_attrs":null,"type_ref":"typing.Collection"}],["float",{".class":"Instance","args":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"}}],"extra_attrs":null,"type_ref":"typing.Collection"}],["complex",{".class":"Instance","args":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"}}],"extra_attrs":null,"type_ref":"typing.Collection"}],["others",{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.flexible"}},{".class":"TypeType","item":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}},{".class":"TypeType","item":"numpy.object_"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"typing.Collection"}]],"readonly_keys":[],"required_keys":["complex","float","int","others","uint"]}}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy._core._type_aliases.__all__","name":"__all__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core._type_aliases.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core._type_aliases.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core._type_aliases.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core._type_aliases.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core._type_aliases.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core._type_aliases.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_abstract_type_names":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy._core._type_aliases._abstract_type_names","name":"_abstract_type_names","setter_type":null,"type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._core._type_aliases.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.set"}}},"_aliases":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy._core._type_aliases._aliases","name":"_aliases","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"numpy._core._type_aliases._AliasesType"}}},"_extra_aliases":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy._core._type_aliases._extra_aliases","name":"_extra_aliases","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"numpy._core._type_aliases._ExtraAliasesType"}}},"allTypes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy._core._type_aliases.allTypes","name":"allTypes","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"TypeType","item":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"}}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"c_names_dict":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy._core._type_aliases.c_names_dict","name":"c_names_dict","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"numpy._core._type_aliases._CNamesDict"}}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"sctypeDict":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy._core._type_aliases.sctypeDict","name":"sctypeDict","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"TypeType","item":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"}}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"sctypes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy._core._type_aliases.sctypes","name":"sctypes","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"numpy._core._type_aliases._SCTypes"}}},"type_check_only":{".class":"SymbolTableNode","cross_ref":"typing.type_check_only","kind":"Gdef","module_hidden":true,"module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_core/_type_aliases.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/_type_aliases.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/_type_aliases.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..88f123d5e6028b9c353b3bb6ed074570d5b25181 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/_type_aliases.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,2,5,1,1,1,1],"dep_prios":[5,5,10,5,30,30,30],"dependencies":["collections.abc","typing","numpy","builtins","_frozen_importlib","abc","datetime"],"hash":"d37899df777e39bbecbfeb7f07057b1895b32e61","id":"numpy._core._type_aliases","ignore_all":true,"interface_hash":"c7c5fb929f6257acd015ac53977cac79825ddf95","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_core/_type_aliases.pyi","plugin_data":null,"size":2388,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/_ufunc_config.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/_ufunc_config.data.json new file mode 100644 index 0000000000000000000000000000000000000000..1b7e7ae477c1fffc9777cef25cc9b396302bbd49 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/_ufunc_config.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy._core._ufunc_config","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef","module_hidden":true,"module_public":false},"Final":{".class":"SymbolTableNode","cross_ref":"typing.Final","kind":"Gdef","module_hidden":true,"module_public":false},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"SupportsWrite":{".class":"SymbolTableNode","cross_ref":"_typeshed.SupportsWrite","kind":"Gdef","module_hidden":true,"module_public":false},"TracebackType":{".class":"SymbolTableNode","cross_ref":"types.TracebackType","kind":"Gdef","module_hidden":true,"module_public":false},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy._core._ufunc_config.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core._ufunc_config.TypeAlias","source_any":null,"type_of_any":3}}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"TypedDict":{".class":"SymbolTableNode","cross_ref":"typing.TypedDict","kind":"Gdef","module_hidden":true,"module_public":false},"_CallableT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._ufunc_config._CallableT","name":"_CallableT","upper_bound":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":"builtins.object","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"values":[],"variance":0}},"_ErrCall":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._core._ufunc_config._ErrCall","name":"_ErrCall","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core._ufunc_config.TypeAlias","source_any":null,"type_of_any":3}}},"_ErrDict":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._core._ufunc_config._ErrDict","name":"_ErrDict","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy._core._ufunc_config._ErrDict","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._core._ufunc_config","mro":["numpy._core._ufunc_config._ErrDict","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["divide",{".class":"AnyType","missing_import_name":"numpy._core._ufunc_config.TypeAlias","source_any":null,"type_of_any":3}],["over",{".class":"AnyType","missing_import_name":"numpy._core._ufunc_config.TypeAlias","source_any":null,"type_of_any":3}],["under",{".class":"AnyType","missing_import_name":"numpy._core._ufunc_config.TypeAlias","source_any":null,"type_of_any":3}],["invalid",{".class":"AnyType","missing_import_name":"numpy._core._ufunc_config.TypeAlias","source_any":null,"type_of_any":3}]],"readonly_keys":[],"required_keys":["divide","invalid","over","under"]}}},"_ErrKind":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._core._ufunc_config._ErrKind","name":"_ErrKind","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core._ufunc_config.TypeAlias","source_any":null,"type_of_any":3}}},"_Unspecified":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy._core._ufunc_config._Unspecified","name":"_Unspecified","setter_type":null,"type":"numpy._core._ufunc_config._unspecified"}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy._core._ufunc_config.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core._ufunc_config.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core._ufunc_config.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core._ufunc_config.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core._ufunc_config.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core._ufunc_config.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core._ufunc_config.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_unspecified":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._core._ufunc_config._unspecified","name":"_unspecified","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy._core._ufunc_config._unspecified","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._core._ufunc_config","mro":["numpy._core._ufunc_config._unspecified","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._ufunc_config._unspecified.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy._core._ufunc_config._unspecified","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"errstate":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._core._ufunc_config.errstate","name":"errstate","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy._core._ufunc_config.errstate","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._core._ufunc_config","mro":["numpy._core._ufunc_config.errstate","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"func"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core._ufunc_config.errstate.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"func"],"arg_types":["numpy._core._ufunc_config.errstate",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._ufunc_config._CallableT","id":-1,"name":"_CallableT","namespace":"numpy._core._ufunc_config.errstate.__call__","upper_bound":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":"builtins.object","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of errstate","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._ufunc_config._CallableT","id":-1,"name":"_CallableT","namespace":"numpy._core._ufunc_config.errstate.__call__","upper_bound":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":"builtins.object","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._ufunc_config._CallableT","id":-1,"name":"_CallableT","namespace":"numpy._core._ufunc_config.errstate.__call__","upper_bound":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":"builtins.object","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"values":[],"variance":0}]}}},"__enter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core._ufunc_config.errstate.__enter__","name":"__enter__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["numpy._core._ufunc_config.errstate"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__enter__ of errstate","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__exit__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":[null,null,null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core._ufunc_config.errstate.__exit__","name":"__exit__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,null,null,null],"arg_types":["numpy._core._ufunc_config.errstate",{".class":"UnionType","items":[{".class":"TypeType","item":"builtins.BaseException"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.BaseException",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["types.TracebackType",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__exit__ of errstate","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5,5,5],"arg_names":[null,"call","all","divide","over","under","invalid"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core._ufunc_config.errstate.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5,5,5],"arg_names":[null,"call","all","divide","over","under","invalid"],"arg_types":["numpy._core._ufunc_config.errstate",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core._ufunc_config.TypeAlias","source_any":null,"type_of_any":3},"numpy._core._ufunc_config._unspecified"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core._ufunc_config.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core._ufunc_config.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core._ufunc_config.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core._ufunc_config.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core._ufunc_config.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of errstate","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"numpy._core._ufunc_config.errstate.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core._ufunc_config.errstate.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy._core._ufunc_config.errstate","values":[],"variance":0},"slots":["_all","_call","_divide","_invalid","_over","_token","_under"],"tuple_type":null,"type_vars":[],"typeddict_type":null}},"getbufsize":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core._ufunc_config.getbufsize","name":"getbufsize","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getbufsize","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"geterr":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core._ufunc_config.geterr","name":"geterr","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"geterr","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy._core._ufunc_config._ErrDict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"geterrcall":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core._ufunc_config.geterrcall","name":"geterrcall","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"geterrcall","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core._ufunc_config.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"setbufsize":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["size"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core._ufunc_config.setbufsize","name":"setbufsize","original_first_arg":"size","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["size"],"arg_types":["builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"setbufsize","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"seterr":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1,1,1,1,1],"arg_names":["all","divide","over","under","invalid"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core._ufunc_config.seterr","name":"seterr","original_first_arg":"all","type":{".class":"CallableType","arg_kinds":[1,1,1,1,1],"arg_names":["all","divide","over","under","invalid"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core._ufunc_config.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core._ufunc_config.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core._ufunc_config.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core._ufunc_config.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core._ufunc_config.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"seterr","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy._core._ufunc_config._ErrDict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"seterrcall":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["func"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core._ufunc_config.seterrcall","name":"seterrcall","original_first_arg":"func","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["func"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core._ufunc_config.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"seterrcall","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core._ufunc_config.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"type_check_only":{".class":"SymbolTableNode","cross_ref":"typing.type_check_only","kind":"Gdef","module_hidden":true,"module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_core/_ufunc_config.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/_ufunc_config.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/_ufunc_config.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..260ce6cce0027817fda6d408842c53c27fa6e8c2 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/_ufunc_config.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106714,"dep_lines":[1,2,3,13,1,1,1,1],"dep_prios":[5,5,5,5,5,30,30,30],"dependencies":["collections.abc","types","typing","_typeshed","builtins","_frozen_importlib","abc","typing_extensions"],"hash":"508bee79336fdc67b02dbe0c3ec658b722e4ed65","id":"numpy._core._ufunc_config","ignore_all":true,"interface_hash":"3ca88d64599bd08566c1843e762f329c50da1737","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_core/_ufunc_config.pyi","plugin_data":null,"size":1890,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/arrayprint.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/arrayprint.data.json new file mode 100644 index 0000000000000000000000000000000000000000..a64924e825557f8586f6d07c7810ab2d19ec4031 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/arrayprint.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy._core.arrayprint","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef","module_hidden":true,"module_public":false},"Final":{".class":"SymbolTableNode","cross_ref":"typing.Final","kind":"Gdef","module_hidden":true,"module_public":false},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"SupportsIndex":{".class":"SymbolTableNode","cross_ref":"typing.SupportsIndex","kind":"Gdef","module_hidden":true,"module_public":false},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy._core.arrayprint.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3}}},"TypedDict":{".class":"SymbolTableNode","cross_ref":"typing.TypedDict","kind":"Gdef","module_hidden":true,"module_public":false},"_CharLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._CharLike_co","kind":"Gdef","module_hidden":true,"module_public":false},"_FloatLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._FloatLike_co","kind":"Gdef","module_hidden":true,"module_public":false},"_FloatMode":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._core.arrayprint._FloatMode","name":"_FloatMode","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3}}},"_FormatDict":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._core.arrayprint._FormatDict","name":"_FormatDict","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy._core.arrayprint._FormatDict","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._core.arrayprint","mro":["numpy._core.arrayprint._FormatDict","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["bool",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],["int",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],["timedelta",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],["datetime",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],["float",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],["longfloat",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],["complexfloat",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],["longcomplexfloat",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],["void",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["numpy.void"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],["numpystr",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],["object",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],["all",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],["int_kind",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],["float_kind",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],["complex_kind",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],["str_kind",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]],"readonly_keys":[],"required_keys":[]}}},"_FormatOptions":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._core.arrayprint._FormatOptions","name":"_FormatOptions","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy._core.arrayprint._FormatOptions","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._core.arrayprint","mro":["numpy._core.arrayprint._FormatOptions","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["precision","builtins.int"],["threshold","builtins.int"],["edgeitems","builtins.int"],["linewidth","builtins.int"],["suppress","builtins.bool"],["nanstr","builtins.str"],["infstr","builtins.str"],["formatter",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._core.arrayprint._FormatDict"},{".class":"NoneType"}],"uses_pep604_syntax":true}],["sign",{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3}],["floatmode",{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3}],["legacy",{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3}]],"readonly_keys":[],"required_keys":["edgeitems","floatmode","formatter","infstr","legacy","linewidth","nanstr","precision","sign","suppress","threshold"]}}},"_GeneratorContextManager":{".class":"SymbolTableNode","cross_ref":"contextlib._GeneratorContextManager","kind":"Gdef","module_hidden":true,"module_public":false},"_Legacy":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._core.arrayprint._Legacy","name":"_Legacy","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3}}},"_LegacyNoStyle":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._core.arrayprint._LegacyNoStyle","name":"_LegacyNoStyle","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3}}},"_NoValueType":{".class":"SymbolTableNode","cross_ref":"numpy._globals._NoValueType","kind":"Gdef","module_hidden":true,"module_public":false},"_ReprFunc":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._core.arrayprint._ReprFunc","name":"_ReprFunc","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3}}},"_Sign":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._core.arrayprint._Sign","name":"_Sign","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3}}},"_Trim":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._core.arrayprint._Trim","name":"_Trim","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3}}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy._core.arrayprint.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.arrayprint.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.arrayprint.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__docformat__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","final_value":"restructuredtext","flags":["is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"numpy._core.arrayprint.__docformat__","name":"__docformat__","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.str","value":"restructuredtext"},"type_ref":"builtins.str"}}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.arrayprint.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.arrayprint.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.arrayprint.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.arrayprint.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"array2string":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.arrayprint.array2string","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1,1,1,1,1,1,1,5],"arg_names":["a","max_line_width","precision","suppress_small","separator","prefix","style","formatter","threshold","edgeitems","sign","floatmode","suffix","legacy"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.arrayprint.array2string","name":"array2string","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,1,1,1,1,1,1,5],"arg_names":["a","max_line_width","precision","suppress_small","separator","prefix","style","formatter","threshold","edgeitems","sign","floatmode","suffix","legacy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str","builtins.str","numpy._globals._NoValueType",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._core.arrayprint._FormatDict"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array2string","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.arrayprint.array2string","name":"array2string","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,1,1,1,1,1,1,5],"arg_names":["a","max_line_width","precision","suppress_small","separator","prefix","style","formatter","threshold","edgeitems","sign","floatmode","suffix","legacy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str","builtins.str","numpy._globals._NoValueType",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._core.arrayprint._FormatDict"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array2string","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0,0,0,1,1,1,1,1,1,3],"arg_names":["a","max_line_width","precision","suppress_small","separator","prefix","style","formatter","threshold","edgeitems","sign","floatmode","suffix","legacy"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.arrayprint.array2string","name":"array2string","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,0,1,1,1,1,1,1,3],"arg_names":["a","max_line_width","precision","suppress_small","separator","prefix","style","formatter","threshold","edgeitems","sign","floatmode","suffix","legacy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str","builtins.str",{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._core.arrayprint._FormatDict"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str",{".class":"LiteralType","fallback":"builtins.str","value":"1.13"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array2string","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.arrayprint.array2string","name":"array2string","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,0,1,1,1,1,1,1,3],"arg_names":["a","max_line_width","precision","suppress_small","separator","prefix","style","formatter","threshold","edgeitems","sign","floatmode","suffix","legacy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str","builtins.str",{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._core.arrayprint._FormatDict"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str",{".class":"LiteralType","fallback":"builtins.str","value":"1.13"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array2string","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,3,5,5,5,5,5,5,3],"arg_names":["a","max_line_width","precision","suppress_small","separator","prefix","style","formatter","threshold","edgeitems","sign","floatmode","suffix","legacy"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.arrayprint.array2string","name":"array2string","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,3,5,5,5,5,5,5,3],"arg_names":["a","max_line_width","precision","suppress_small","separator","prefix","style","formatter","threshold","edgeitems","sign","floatmode","suffix","legacy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str","builtins.str",{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._core.arrayprint._FormatDict"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str",{".class":"LiteralType","fallback":"builtins.str","value":"1.13"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array2string","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.arrayprint.array2string","name":"array2string","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,3,5,5,5,5,5,5,3],"arg_names":["a","max_line_width","precision","suppress_small","separator","prefix","style","formatter","threshold","edgeitems","sign","floatmode","suffix","legacy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str","builtins.str",{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._core.arrayprint._FormatDict"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str",{".class":"LiteralType","fallback":"builtins.str","value":"1.13"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array2string","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0,0,0,1,1,1,1,1,1,5],"arg_names":["a","max_line_width","precision","suppress_small","separator","prefix","style","formatter","threshold","edgeitems","sign","floatmode","suffix","legacy"],"dataclass_transform_spec":null,"deprecated":"overload def (a: Any, max_line_width: builtins.int | None, precision: typing.SupportsIndex | None, suppress_small: builtins.bool | None, separator: builtins.str, prefix: builtins.str, style: Any, formatter: TypedDict('numpy._core.arrayprint._FormatDict', {'bool'?: def (numpy.bool[builtins.bool]) -> builtins.str, 'int'?: def (numpy.integer[Any]) -> builtins.str, 'timedelta'?: def (numpy.timedelta64[datetime.timedelta | builtins.int | None]) -> builtins.str, 'datetime'?: def (numpy.datetime64[datetime.date | builtins.int | None]) -> builtins.str, 'float'?: def (numpy.floating[Any]) -> builtins.str, 'longfloat'?: def (Any) -> builtins.str, 'complexfloat'?: def (numpy.complexfloating[Any, Any]) -> builtins.str, 'longcomplexfloat'?: def (Any) -> builtins.str, 'void'?: def (numpy.void) -> builtins.str, 'numpystr'?: def (Any) -> builtins.str, 'object'?: def (builtins.object) -> builtins.str, 'all'?: def (builtins.object) -> builtins.str, 'int_kind'?: def (numpy.integer[Any]) -> builtins.str, 'float_kind'?: def (numpy.floating[Any]) -> builtins.str, 'complex_kind'?: def (numpy.complexfloating[Any, Any]) -> builtins.str, 'str_kind'?: def (Any) -> builtins.str}) | None =, threshold: builtins.int | None =, edgeitems: builtins.int | None =, sign: Any | None =, floatmode: Any | None =, suffix: builtins.str =, *, legacy: Any | None =) -> builtins.str of function numpy._core.arrayprint.array2string is deprecated: 'style' argument is deprecated and no longer functional except in 1.13 'legacy' mode","flags":["is_overload","is_decorated"],"fullname":"numpy._core.arrayprint.array2string","name":"array2string","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,0,1,1,1,1,1,1,5],"arg_names":["a","max_line_width","precision","suppress_small","separator","prefix","style","formatter","threshold","edgeitems","sign","floatmode","suffix","legacy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str","builtins.str",{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._core.arrayprint._FormatDict"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array2string","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.arrayprint.array2string","name":"array2string","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,0,1,1,1,1,1,1,5],"arg_names":["a","max_line_width","precision","suppress_small","separator","prefix","style","formatter","threshold","edgeitems","sign","floatmode","suffix","legacy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str","builtins.str",{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._core.arrayprint._FormatDict"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array2string","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,3,5,5,5,5,5,5,5],"arg_names":["a","max_line_width","precision","suppress_small","separator","prefix","style","formatter","threshold","edgeitems","sign","floatmode","suffix","legacy"],"dataclass_transform_spec":null,"deprecated":"overload def (a: Any, max_line_width: builtins.int | None =, precision: typing.SupportsIndex | None =, suppress_small: builtins.bool | None =, separator: builtins.str =, prefix: builtins.str =, *, style: Any, formatter: TypedDict('numpy._core.arrayprint._FormatDict', {'bool'?: def (numpy.bool[builtins.bool]) -> builtins.str, 'int'?: def (numpy.integer[Any]) -> builtins.str, 'timedelta'?: def (numpy.timedelta64[datetime.timedelta | builtins.int | None]) -> builtins.str, 'datetime'?: def (numpy.datetime64[datetime.date | builtins.int | None]) -> builtins.str, 'float'?: def (numpy.floating[Any]) -> builtins.str, 'longfloat'?: def (Any) -> builtins.str, 'complexfloat'?: def (numpy.complexfloating[Any, Any]) -> builtins.str, 'longcomplexfloat'?: def (Any) -> builtins.str, 'void'?: def (numpy.void) -> builtins.str, 'numpystr'?: def (Any) -> builtins.str, 'object'?: def (builtins.object) -> builtins.str, 'all'?: def (builtins.object) -> builtins.str, 'int_kind'?: def (numpy.integer[Any]) -> builtins.str, 'float_kind'?: def (numpy.floating[Any]) -> builtins.str, 'complex_kind'?: def (numpy.complexfloating[Any, Any]) -> builtins.str, 'str_kind'?: def (Any) -> builtins.str}) | None =, threshold: builtins.int | None =, edgeitems: builtins.int | None =, sign: Any | None =, floatmode: Any | None =, suffix: builtins.str =, legacy: Any | None =) -> builtins.str of function numpy._core.arrayprint.array2string is deprecated: 'style' argument is deprecated and no longer functional except in 1.13 'legacy' mode","flags":["is_overload","is_decorated"],"fullname":"numpy._core.arrayprint.array2string","name":"array2string","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,3,5,5,5,5,5,5,5],"arg_names":["a","max_line_width","precision","suppress_small","separator","prefix","style","formatter","threshold","edgeitems","sign","floatmode","suffix","legacy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str","builtins.str",{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._core.arrayprint._FormatDict"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array2string","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.arrayprint.array2string","name":"array2string","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,3,5,5,5,5,5,5,5],"arg_names":["a","max_line_width","precision","suppress_small","separator","prefix","style","formatter","threshold","edgeitems","sign","floatmode","suffix","legacy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str","builtins.str",{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._core.arrayprint._FormatDict"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array2string","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,1,1,1,1,1,1,5],"arg_names":["a","max_line_width","precision","suppress_small","separator","prefix","style","formatter","threshold","edgeitems","sign","floatmode","suffix","legacy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str","builtins.str","numpy._globals._NoValueType",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._core.arrayprint._FormatDict"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array2string","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,0,1,1,1,1,1,1,3],"arg_names":["a","max_line_width","precision","suppress_small","separator","prefix","style","formatter","threshold","edgeitems","sign","floatmode","suffix","legacy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str","builtins.str",{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._core.arrayprint._FormatDict"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str",{".class":"LiteralType","fallback":"builtins.str","value":"1.13"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array2string","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,3,5,5,5,5,5,5,3],"arg_names":["a","max_line_width","precision","suppress_small","separator","prefix","style","formatter","threshold","edgeitems","sign","floatmode","suffix","legacy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str","builtins.str",{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._core.arrayprint._FormatDict"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str",{".class":"LiteralType","fallback":"builtins.str","value":"1.13"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array2string","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,0,1,1,1,1,1,1,5],"arg_names":["a","max_line_width","precision","suppress_small","separator","prefix","style","formatter","threshold","edgeitems","sign","floatmode","suffix","legacy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str","builtins.str",{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._core.arrayprint._FormatDict"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array2string","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,3,5,5,5,5,5,5,5],"arg_names":["a","max_line_width","precision","suppress_small","separator","prefix","style","formatter","threshold","edgeitems","sign","floatmode","suffix","legacy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str","builtins.str",{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._core.arrayprint._FormatDict"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array2string","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"array_repr":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["arr","max_line_width","precision","suppress_small"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.arrayprint.array_repr","name":"array_repr","original_first_arg":"arr","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["arr","max_line_width","precision","suppress_small"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array_repr","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"array_str":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["a","max_line_width","precision","suppress_small"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.arrayprint.array_str","name":"array_str","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","max_line_width","precision","suppress_small"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array_str","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"deprecated":{".class":"SymbolTableNode","cross_ref":"typing_extensions.deprecated","kind":"Gdef","module_hidden":true,"module_public":false},"format_float_positional":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1,1,1],"arg_names":["x","precision","unique","fractional","trim","sign","pad_left","pad_right","min_digits"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.arrayprint.format_float_positional","name":"format_float_positional","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,1,1],"arg_names":["x","precision","unique","fractional","trim","sign","pad_left","pad_right","min_digits"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool",{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"format_float_positional","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"format_float_scientific":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1,1],"arg_names":["x","precision","unique","trim","sign","pad_left","exp_digits","min_digits"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.arrayprint.format_float_scientific","name":"format_float_scientific","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,1],"arg_names":["x","precision","unique","trim","sign","pad_left","exp_digits","min_digits"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"format_float_scientific","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_printoptions":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.arrayprint.get_printoptions","name":"get_printoptions","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_printoptions","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy._core.arrayprint._FormatOptions"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false},"printoptions":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1,1,1,1,1,1,1,1,1,1,5,5],"arg_names":["precision","threshold","edgeitems","linewidth","suppress","nanstr","infstr","formatter","sign","floatmode","legacy","override_repr"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.arrayprint.printoptions","name":"printoptions","original_first_arg":"precision","type":{".class":"CallableType","arg_kinds":[1,1,1,1,1,1,1,1,1,1,5,5],"arg_names":["precision","threshold","edgeitems","linewidth","suppress","nanstr","infstr","formatter","sign","floatmode","legacy","override_repr"],"arg_types":[{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._core.arrayprint._FormatDict"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"printoptions","ret_type":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._core.arrayprint._FormatOptions"},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"set_printoptions":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1,1,1,1,1,1,1,1,1,1,5,5],"arg_names":["precision","threshold","edgeitems","linewidth","suppress","nanstr","infstr","formatter","sign","floatmode","legacy","override_repr"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.arrayprint.set_printoptions","name":"set_printoptions","original_first_arg":"precision","type":{".class":"CallableType","arg_kinds":[1,1,1,1,1,1,1,1,1,1,5,5],"arg_names":["precision","threshold","edgeitems","linewidth","suppress","nanstr","infstr","formatter","sign","floatmode","legacy","override_repr"],"arg_types":[{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._core.arrayprint._FormatDict"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.arrayprint.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"set_printoptions","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"type_check_only":{".class":"SymbolTableNode","cross_ref":"typing.type_check_only","kind":"Gdef","module_hidden":true,"module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_core/arrayprint.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/arrayprint.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/arrayprint.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..c2d9ad7c1e0fe2c4532b0a47ab60a3b32625688b --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/arrayprint.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,20,21,5,6,17,19,1,1,1,1,1],"dep_prios":[5,5,5,5,5,5,10,5,30,30,30,30],"dependencies":["collections.abc","numpy._globals","numpy._typing","contextlib","typing","typing_extensions","numpy","builtins","_frozen_importlib","abc","datetime","numpy._typing._array_like"],"hash":"a35b2ef5fb714771ed13245489940a77f3a935d3","id":"numpy._core.arrayprint","ignore_all":true,"interface_hash":"f5aaa2e3444ba3c1c1d659925512fca676c8cc80","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_core/arrayprint.pyi","plugin_data":null,"size":6971,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/defchararray.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/defchararray.data.json new file mode 100644 index 0000000000000000000000000000000000000000..6b5e9fe026840fe40a8faca02999da947a85906c --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/defchararray.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy._core.defchararray","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"L":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"S_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeBytes_co","kind":"Gdef","module_hidden":true,"module_public":false},"Self":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy._core.defchararray.Self","name":"Self","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.Self","source_any":null,"type_of_any":3}}},"SupportsIndex":{".class":"SymbolTableNode","cross_ref":"typing.SupportsIndex","kind":"Gdef","module_hidden":true,"module_public":false},"SupportsInt":{".class":"SymbolTableNode","cross_ref":"typing.SupportsInt","kind":"Gdef","module_hidden":true,"module_public":false},"T_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeString_co","kind":"Gdef","module_hidden":true,"module_public":false},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy._core.defchararray.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing_extensions.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"UST_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeAnyString_co","kind":"Gdef","module_hidden":true,"module_public":false},"U_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeStr_co","kind":"Gdef","module_hidden":true,"module_public":false},"_AnyShape":{".class":"SymbolTableNode","cross_ref":"numpy._typing._shape._AnyShape","kind":"Gdef","module_hidden":true,"module_public":false},"_CharArray":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._core.defchararray._CharArray","name":"_CharArray","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}}},"_CharDTypeT_co":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.defchararray._CharDTypeT_co","name":"_CharDTypeT_co","upper_bound":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}},"_CharacterT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.defchararray._CharacterT","name":"_CharacterT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"},"values":[],"variance":0}},"_OrderKACF":{".class":"SymbolTableNode","cross_ref":"numpy._OrderKACF","kind":"Gdef","module_hidden":true,"module_public":false},"_Shape":{".class":"SymbolTableNode","cross_ref":"numpy._typing._shape._Shape","kind":"Gdef","module_hidden":true,"module_public":false},"_ShapeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._shape._ShapeLike","kind":"Gdef","module_hidden":true,"module_public":false},"_ShapeT_co":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","name":"_ShapeT_co","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1}},"_StringDTypeArray":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._core.defchararray._StringDTypeArray","name":"_StringDTypeArray","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}}},"_StringDTypeOrUnicodeArray":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._core.defchararray._StringDTypeOrUnicodeArray","name":"_StringDTypeOrUnicodeArray","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}}},"_StringDTypeSupportsArray":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._core.defchararray._StringDTypeSupportsArray","name":"_StringDTypeSupportsArray","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}}},"_SupportsArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._SupportsArray","kind":"Gdef","module_hidden":true,"module_public":false},"_SupportsBuffer":{".class":"SymbolTableNode","cross_ref":"numpy._SupportsBuffer","kind":"Gdef","module_hidden":true,"module_public":false},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy._core.defchararray.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.defchararray.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.defchararray.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.defchararray.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.defchararray.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.defchararray.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.defchararray.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"add":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.add","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.add","name":"add","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.add","name":"add","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.add","name":"add","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.add","name":"add","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.add","name":"add","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.add","name":"add","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.add","name":"add","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.add","name":"add","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"array":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.array","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["obj","itemsize","copy","unicode","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.array","name":"array","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["obj","itemsize","copy","unicode","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.array","name":"array","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["obj","itemsize","copy","unicode","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["obj","itemsize","copy","unicode","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.array","name":"array","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["obj","itemsize","copy","unicode","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.array","name":"array","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["obj","itemsize","copy","unicode","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1],"arg_names":["obj","itemsize","copy","unicode","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.array","name":"array","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["obj","itemsize","copy","unicode","order"],"arg_types":["builtins.object",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.array","name":"array","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["obj","itemsize","copy","unicode","order"],"arg_types":["builtins.object",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,3,5],"arg_names":["obj","itemsize","copy","unicode","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.array","name":"array","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["obj","itemsize","copy","unicode","order"],"arg_types":["builtins.object",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.array","name":"array","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["obj","itemsize","copy","unicode","order"],"arg_types":["builtins.object",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1],"arg_names":["obj","itemsize","copy","unicode","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.array","name":"array","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["obj","itemsize","copy","unicode","order"],"arg_types":["builtins.object",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.array","name":"array","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["obj","itemsize","copy","unicode","order"],"arg_types":["builtins.object",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,3,5],"arg_names":["obj","itemsize","copy","unicode","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.array","name":"array","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["obj","itemsize","copy","unicode","order"],"arg_types":["builtins.object",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.array","name":"array","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["obj","itemsize","copy","unicode","order"],"arg_types":["builtins.object",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["obj","itemsize","copy","unicode","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.array","name":"array","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["obj","itemsize","copy","unicode","order"],"arg_types":["builtins.object",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.array","name":"array","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["obj","itemsize","copy","unicode","order"],"arg_types":["builtins.object",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["obj","itemsize","copy","unicode","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["obj","itemsize","copy","unicode","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["obj","itemsize","copy","unicode","order"],"arg_types":["builtins.object",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["obj","itemsize","copy","unicode","order"],"arg_types":["builtins.object",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["obj","itemsize","copy","unicode","order"],"arg_types":["builtins.object",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["obj","itemsize","copy","unicode","order"],"arg_types":["builtins.object",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["obj","itemsize","copy","unicode","order"],"arg_types":["builtins.object",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"asarray":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.asarray","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["obj","itemsize","unicode","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.asarray","name":"asarray","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["obj","itemsize","unicode","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.asarray","name":"asarray","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["obj","itemsize","unicode","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["obj","itemsize","unicode","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.asarray","name":"asarray","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["obj","itemsize","unicode","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.asarray","name":"asarray","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["obj","itemsize","unicode","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["obj","itemsize","unicode","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.asarray","name":"asarray","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["obj","itemsize","unicode","order"],"arg_types":["builtins.object",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.asarray","name":"asarray","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["obj","itemsize","unicode","order"],"arg_types":["builtins.object",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3,5],"arg_names":["obj","itemsize","unicode","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.asarray","name":"asarray","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["obj","itemsize","unicode","order"],"arg_types":["builtins.object",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.asarray","name":"asarray","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["obj","itemsize","unicode","order"],"arg_types":["builtins.object",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["obj","itemsize","unicode","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.asarray","name":"asarray","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["obj","itemsize","unicode","order"],"arg_types":["builtins.object",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.asarray","name":"asarray","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["obj","itemsize","unicode","order"],"arg_types":["builtins.object",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3,5],"arg_names":["obj","itemsize","unicode","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.asarray","name":"asarray","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["obj","itemsize","unicode","order"],"arg_types":["builtins.object",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.asarray","name":"asarray","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["obj","itemsize","unicode","order"],"arg_types":["builtins.object",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["obj","itemsize","unicode","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.asarray","name":"asarray","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["obj","itemsize","unicode","order"],"arg_types":["builtins.object",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.asarray","name":"asarray","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["obj","itemsize","unicode","order"],"arg_types":["builtins.object",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["obj","itemsize","unicode","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["obj","itemsize","unicode","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["obj","itemsize","unicode","order"],"arg_types":["builtins.object",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["obj","itemsize","unicode","order"],"arg_types":["builtins.object",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["obj","itemsize","unicode","order"],"arg_types":["builtins.object",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["obj","itemsize","unicode","order"],"arg_types":["builtins.object",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["obj","itemsize","unicode","order"],"arg_types":["builtins.object",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"b_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeBool_co","kind":"Gdef","module_hidden":true,"module_public":false},"bytes_":{".class":"SymbolTableNode","cross_ref":"numpy.bytes_","kind":"Gdef","module_hidden":true,"module_public":false},"capitalize":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.capitalize","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.capitalize","name":"capitalize","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"capitalize","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.capitalize","name":"capitalize","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"capitalize","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.capitalize","name":"capitalize","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"capitalize","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.capitalize","name":"capitalize","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"capitalize","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.capitalize","name":"capitalize","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"capitalize","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.capitalize","name":"capitalize","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"capitalize","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.capitalize","name":"capitalize","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"capitalize","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.capitalize","name":"capitalize","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"capitalize","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"capitalize","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"capitalize","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"capitalize","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"capitalize","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"center":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.center","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.center","name":"center","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"center","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.center","name":"center","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"center","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.center","name":"center","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"center","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.center","name":"center","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"center","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.center","name":"center","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"center","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.center","name":"center","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"center","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.center","name":"center","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"center","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.center","name":"center","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"center","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"center","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"center","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"center","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"center","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"chararray":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.defchararray._CharDTypeT_co","id":2,"name":"_CharDTypeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ndarray"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._core.defchararray.chararray","name":"chararray","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.defchararray._CharDTypeT_co","id":2,"name":"_CharDTypeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.chararray","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._core.defchararray","mro":["numpy._core.defchararray.chararray","numpy.ndarray","numpy._ArrayOrScalarCommon","builtins.object"],"names":{".class":"SymbolTable","__add__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.chararray.__add__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.__add__","name":"__add__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__add__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.__add__","name":"__add__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__add__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.__add__","name":"__add__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__add__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.__add__","name":"__add__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__add__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__add__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__add__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"__array_finalize__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core.defchararray.chararray.__array_finalize__","name":"__array_finalize__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","obj"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.defchararray._CharDTypeT_co","id":2,"name":"_CharDTypeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.defchararray.chararray"},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__array_finalize__ of chararray","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__eq__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.chararray.__eq__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.__eq__","name":"__eq__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__eq__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.__eq__","name":"__eq__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__eq__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.__eq__","name":"__eq__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__eq__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.__eq__","name":"__eq__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__eq__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__eq__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__eq__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"__ge__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.chararray.__ge__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.__ge__","name":"__ge__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ge__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.__ge__","name":"__ge__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ge__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.__ge__","name":"__ge__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ge__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.__ge__","name":"__ge__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ge__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ge__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ge__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"__gt__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.chararray.__gt__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.__gt__","name":"__gt__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__gt__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.__gt__","name":"__gt__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__gt__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.__gt__","name":"__gt__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__gt__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.__gt__","name":"__gt__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__gt__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__gt__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__gt__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"__le__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.chararray.__le__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.__le__","name":"__le__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__le__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.__le__","name":"__le__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__le__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.__le__","name":"__le__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__le__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.__le__","name":"__le__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__le__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__le__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__le__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"__lt__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.chararray.__lt__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.__lt__","name":"__lt__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__lt__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.__lt__","name":"__lt__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__lt__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.__lt__","name":"__lt__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__lt__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.__lt__","name":"__lt__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__lt__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__lt__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__lt__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"__mod__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core.defchararray.chararray.__mod__","name":"__mod__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.defchararray._CharDTypeT_co","id":2,"name":"_CharDTypeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.defchararray.chararray"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mod__ of chararray","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.defchararray._CharDTypeT_co","id":2,"name":"_CharDTypeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.defchararray.chararray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__mul__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core.defchararray.chararray.__mul__","name":"__mul__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.defchararray._CharDTypeT_co","id":2,"name":"_CharDTypeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.defchararray.chararray"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mul__ of chararray","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.defchararray._CharDTypeT_co","id":2,"name":"_CharDTypeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.defchararray.chararray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__ne__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.chararray.__ne__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.__ne__","name":"__ne__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ne__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.__ne__","name":"__ne__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ne__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.__ne__","name":"__ne__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ne__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.__ne__","name":"__ne__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ne__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ne__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ne__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"__new__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":["is_static"],"fullname":"numpy._core.defchararray.chararray.__new__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,1],"arg_names":["subtype","shape","itemsize","unicode","buffer","offset","strides","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._core.defchararray.chararray.__new__","name":"__new__","original_first_arg":"subtype","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1],"arg_names":["subtype","shape","itemsize","unicode","buffer","offset","strides","order"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.defchararray._CharDTypeT_co","id":2,"name":"_CharDTypeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.defchararray.chararray"}},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex","typing.SupportsInt"],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.__new__","name":"__new__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1],"arg_names":["subtype","shape","itemsize","unicode","buffer","offset","strides","order"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.defchararray._CharDTypeT_co","id":2,"name":"_CharDTypeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.defchararray.chararray"}},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex","typing.SupportsInt"],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,1],"arg_names":["subtype","shape","itemsize","unicode","buffer","offset","strides","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._core.defchararray.chararray.__new__","name":"__new__","original_first_arg":"subtype","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1],"arg_names":["subtype","shape","itemsize","unicode","buffer","offset","strides","order"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.defchararray._CharDTypeT_co","id":2,"name":"_CharDTypeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.defchararray.chararray"}},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex","typing.SupportsInt"],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.__new__","name":"__new__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1],"arg_names":["subtype","shape","itemsize","unicode","buffer","offset","strides","order"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.defchararray._CharDTypeT_co","id":2,"name":"_CharDTypeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.defchararray.chararray"}},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex","typing.SupportsInt"],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1],"arg_names":["subtype","shape","itemsize","unicode","buffer","offset","strides","order"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.defchararray._CharDTypeT_co","id":2,"name":"_CharDTypeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.defchararray.chararray"}},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex","typing.SupportsInt"],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1],"arg_names":["subtype","shape","itemsize","unicode","buffer","offset","strides","order"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.defchararray._CharDTypeT_co","id":2,"name":"_CharDTypeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.defchararray.chararray"}},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex","typing.SupportsInt"],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"__radd__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.chararray.__radd__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.__radd__","name":"__radd__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__radd__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.__radd__","name":"__radd__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__radd__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.__radd__","name":"__radd__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__radd__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.__radd__","name":"__radd__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__radd__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__radd__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__radd__ of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"__rmul__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core.defchararray.chararray.__rmul__","name":"__rmul__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.defchararray._CharDTypeT_co","id":2,"name":"_CharDTypeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.defchararray.chararray"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__rmul__ of chararray","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.defchararray._CharDTypeT_co","id":2,"name":"_CharDTypeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.defchararray.chararray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"capitalize":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core.defchararray.chararray.capitalize","name":"capitalize","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.defchararray._CharDTypeT_co","id":2,"name":"_CharDTypeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.defchararray.chararray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"capitalize of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"center":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.chararray.center","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","width","fillchar"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.center","name":"center","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"center of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.center","name":"center","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"center of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","width","fillchar"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.center","name":"center","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"center of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.center","name":"center","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"center of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"center of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"center of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"count":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.chararray.count","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.count","name":"count","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.count","name":"count","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.count","name":"count","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.count","name":"count","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"decode":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["self","encoding","errors"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.chararray.decode","name":"decode","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","encoding","errors"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"decode of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"encode":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["self","encoding","errors"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.chararray.encode","name":"encode","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","encoding","errors"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"encode of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"endswith":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.chararray.endswith","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","suffix","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.endswith","name":"endswith","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","suffix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"endswith of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.endswith","name":"endswith","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","suffix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"endswith of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","suffix","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.endswith","name":"endswith","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","suffix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"endswith of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.endswith","name":"endswith","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","suffix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"endswith of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","suffix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"endswith of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","suffix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"endswith of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"expandtabs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","tabsize"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core.defchararray.chararray.expandtabs","name":"expandtabs","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","tabsize"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.defchararray._CharDTypeT_co","id":2,"name":"_CharDTypeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.defchararray.chararray"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"expandtabs of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"find":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.chararray.find","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.find","name":"find","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"find of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.find","name":"find","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"find of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.find","name":"find","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"find of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.find","name":"find","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"find of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"find of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"find of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"index":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.chararray.index","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.index","name":"index","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"index of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.index","name":"index","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"index of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.index","name":"index","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"index of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.index","name":"index","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"index of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"index of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"index of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"isalnum":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core.defchararray.chararray.isalnum","name":"isalnum","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.defchararray._CharDTypeT_co","id":2,"name":"_CharDTypeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.defchararray.chararray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isalnum of chararray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"Instance","args":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isalpha":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core.defchararray.chararray.isalpha","name":"isalpha","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.defchararray._CharDTypeT_co","id":2,"name":"_CharDTypeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.defchararray.chararray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isalpha of chararray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"Instance","args":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isdecimal":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core.defchararray.chararray.isdecimal","name":"isdecimal","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.defchararray._CharDTypeT_co","id":2,"name":"_CharDTypeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.defchararray.chararray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isdecimal of chararray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"Instance","args":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isdigit":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core.defchararray.chararray.isdigit","name":"isdigit","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.defchararray._CharDTypeT_co","id":2,"name":"_CharDTypeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.defchararray.chararray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isdigit of chararray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"Instance","args":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"islower":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core.defchararray.chararray.islower","name":"islower","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.defchararray._CharDTypeT_co","id":2,"name":"_CharDTypeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.defchararray.chararray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"islower of chararray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"Instance","args":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isnumeric":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core.defchararray.chararray.isnumeric","name":"isnumeric","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.defchararray._CharDTypeT_co","id":2,"name":"_CharDTypeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.defchararray.chararray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isnumeric of chararray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"Instance","args":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isspace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core.defchararray.chararray.isspace","name":"isspace","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.defchararray._CharDTypeT_co","id":2,"name":"_CharDTypeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.defchararray.chararray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isspace of chararray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"Instance","args":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"istitle":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core.defchararray.chararray.istitle","name":"istitle","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.defchararray._CharDTypeT_co","id":2,"name":"_CharDTypeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.defchararray.chararray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"istitle of chararray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"Instance","args":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isupper":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core.defchararray.chararray.isupper","name":"isupper","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.defchararray._CharDTypeT_co","id":2,"name":"_CharDTypeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.defchararray.chararray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isupper of chararray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"Instance","args":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"join":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.chararray.join","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","seq"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.join","name":"join","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","seq"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"join of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.join","name":"join","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","seq"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"join of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","seq"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.join","name":"join","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","seq"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"join of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.join","name":"join","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","seq"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"join of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","seq"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"join of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","seq"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"join of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"ljust":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.chararray.ljust","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","width","fillchar"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.ljust","name":"ljust","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ljust of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.ljust","name":"ljust","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ljust of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","width","fillchar"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.ljust","name":"ljust","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ljust of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.ljust","name":"ljust","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ljust of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ljust of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ljust of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"lower":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core.defchararray.chararray.lower","name":"lower","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.defchararray._CharDTypeT_co","id":2,"name":"_CharDTypeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.defchararray.chararray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lower of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"lstrip":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.chararray.lstrip","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","chars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.lstrip","name":"lstrip","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstrip of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.lstrip","name":"lstrip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstrip of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","chars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.lstrip","name":"lstrip","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstrip of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.lstrip","name":"lstrip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstrip of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstrip of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstrip of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"partition":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.chararray.partition","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","sep"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.partition","name":"partition","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.partition","name":"partition","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","sep"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.partition","name":"partition","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.partition","name":"partition","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.chararray.replace","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","old","new","count"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.replace","name":"replace","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","old","new","count"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.replace","name":"replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","old","new","count"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","old","new","count"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.replace","name":"replace","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","old","new","count"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.replace","name":"replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","old","new","count"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","old","new","count"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","old","new","count"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"rfind":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.chararray.rfind","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.rfind","name":"rfind","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rfind of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.rfind","name":"rfind","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rfind of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.rfind","name":"rfind","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rfind of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.rfind","name":"rfind","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rfind of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rfind of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rfind of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"rindex":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.chararray.rindex","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.rindex","name":"rindex","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rindex of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.rindex","name":"rindex","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rindex of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.rindex","name":"rindex","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rindex of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.rindex","name":"rindex","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rindex of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rindex of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rindex of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"rjust":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.chararray.rjust","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","width","fillchar"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.rjust","name":"rjust","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rjust of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.rjust","name":"rjust","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rjust of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","width","fillchar"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.rjust","name":"rjust","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rjust of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.rjust","name":"rjust","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rjust of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rjust of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rjust of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"rpartition":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.chararray.rpartition","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","sep"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.rpartition","name":"rpartition","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rpartition of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.rpartition","name":"rpartition","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rpartition of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","sep"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.rpartition","name":"rpartition","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rpartition of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.rpartition","name":"rpartition","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rpartition of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rpartition of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rpartition of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"rsplit":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.chararray.rsplit","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["self","sep","maxsplit"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.rsplit","name":"rsplit","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","sep","maxsplit"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rsplit of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.rsplit","name":"rsplit","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","sep","maxsplit"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rsplit of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["self","sep","maxsplit"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.rsplit","name":"rsplit","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","sep","maxsplit"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rsplit of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.rsplit","name":"rsplit","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","sep","maxsplit"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rsplit of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","sep","maxsplit"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rsplit of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","sep","maxsplit"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rsplit of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"rstrip":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.chararray.rstrip","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","chars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.rstrip","name":"rstrip","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rstrip of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.rstrip","name":"rstrip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rstrip of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","chars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.rstrip","name":"rstrip","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rstrip of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.rstrip","name":"rstrip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rstrip of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rstrip of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rstrip of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"split":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.chararray.split","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["self","sep","maxsplit"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.split","name":"split","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","sep","maxsplit"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"split of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.split","name":"split","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","sep","maxsplit"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"split of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["self","sep","maxsplit"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.split","name":"split","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","sep","maxsplit"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"split of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.split","name":"split","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","sep","maxsplit"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"split of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","sep","maxsplit"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"split of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","sep","maxsplit"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"split of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"splitlines":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","keepends"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core.defchararray.chararray.splitlines","name":"splitlines","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","keepends"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.defchararray._CharDTypeT_co","id":2,"name":"_CharDTypeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.defchararray.chararray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"splitlines of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"startswith":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.chararray.startswith","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","prefix","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.startswith","name":"startswith","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","prefix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"startswith of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.startswith","name":"startswith","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","prefix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"startswith of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","prefix","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.startswith","name":"startswith","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","prefix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"startswith of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.startswith","name":"startswith","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","prefix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"startswith of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","prefix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"startswith of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","prefix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"startswith of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"strip":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.chararray.strip","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","chars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.strip","name":"strip","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strip of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.strip","name":"strip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strip of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","chars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.strip","name":"strip","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strip of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.strip","name":"strip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strip of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strip of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strip of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"swapcase":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core.defchararray.chararray.swapcase","name":"swapcase","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.defchararray._CharDTypeT_co","id":2,"name":"_CharDTypeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.defchararray.chararray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"swapcase of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"title":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core.defchararray.chararray.title","name":"title","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.defchararray._CharDTypeT_co","id":2,"name":"_CharDTypeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.defchararray.chararray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"title of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"translate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.chararray.translate","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","table","deletechars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.translate","name":"translate","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","table","deletechars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"translate of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.translate","name":"translate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","table","deletechars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"translate of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","table","deletechars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.chararray.translate","name":"translate","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","table","deletechars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"translate of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.chararray.translate","name":"translate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","table","deletechars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"translate of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","table","deletechars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"translate of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","table","deletechars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"translate of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"upper":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core.defchararray.chararray.upper","name":"upper","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.defchararray._CharDTypeT_co","id":2,"name":"_CharDTypeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.defchararray.chararray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"upper of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"zfill":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","width"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core.defchararray.chararray.zfill","name":"zfill","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","width"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.defchararray._CharDTypeT_co","id":2,"name":"_CharDTypeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.defchararray.chararray"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zfill of chararray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.defchararray.chararray.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.defchararray._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.defchararray._CharDTypeT_co","id":2,"name":"_CharDTypeT_co","namespace":"numpy._core.defchararray.chararray","upper_bound":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.defchararray.chararray"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_ShapeT_co","_CharDTypeT_co"],"typeddict_type":null}},"compare_chararrays":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.compare_chararrays","kind":"Gdef"},"count":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.count","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.count","name":"count","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.count","name":"count","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.count","name":"count","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.count","name":"count","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.count","name":"count","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.count","name":"count","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"decode":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["a","encoding","errors"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.decode","name":"decode","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","encoding","errors"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"decode","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"dtype":{".class":"SymbolTableNode","cross_ref":"numpy.dtype","kind":"Gdef","module_hidden":true,"module_public":false},"encode":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["a","encoding","errors"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.encode","name":"encode","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","encoding","errors"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"encode","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"endswith":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.endswith","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","suffix","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.endswith","name":"endswith","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","suffix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"endswith","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.endswith","name":"endswith","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","suffix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"endswith","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","suffix","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.endswith","name":"endswith","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","suffix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"endswith","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.endswith","name":"endswith","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","suffix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"endswith","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","suffix","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.endswith","name":"endswith","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","suffix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"endswith","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.endswith","name":"endswith","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","suffix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"endswith","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","suffix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"endswith","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","suffix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"endswith","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","suffix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"endswith","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"equal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.equal","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.equal","name":"equal","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.equal","name":"equal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.equal","name":"equal","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.equal","name":"equal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.equal","name":"equal","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.equal","name":"equal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"expandtabs":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.expandtabs","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","tabsize"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.expandtabs","name":"expandtabs","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tabsize"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"expandtabs","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.expandtabs","name":"expandtabs","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tabsize"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"expandtabs","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","tabsize"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.expandtabs","name":"expandtabs","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tabsize"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"expandtabs","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.expandtabs","name":"expandtabs","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tabsize"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"expandtabs","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","tabsize"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.expandtabs","name":"expandtabs","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tabsize"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"expandtabs","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.expandtabs","name":"expandtabs","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tabsize"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"expandtabs","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","tabsize"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.expandtabs","name":"expandtabs","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tabsize"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"expandtabs","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.expandtabs","name":"expandtabs","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tabsize"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"expandtabs","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tabsize"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"expandtabs","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tabsize"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"expandtabs","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tabsize"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"expandtabs","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tabsize"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"expandtabs","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"find":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.find","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.find","name":"find","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"find","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.find","name":"find","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"find","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.find","name":"find","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"find","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.find","name":"find","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"find","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.find","name":"find","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"find","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.find","name":"find","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"find","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"find","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"find","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"find","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"greater":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.greater","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.greater","name":"greater","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.greater","name":"greater","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.greater","name":"greater","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.greater","name":"greater","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.greater","name":"greater","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.greater","name":"greater","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"greater_equal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.greater_equal","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.greater_equal","name":"greater_equal","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.greater_equal","name":"greater_equal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.greater_equal","name":"greater_equal","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.greater_equal","name":"greater_equal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.greater_equal","name":"greater_equal","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.greater_equal","name":"greater_equal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"i_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeInt_co","kind":"Gdef","module_hidden":true,"module_public":false},"index":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.index","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.index","name":"index","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"index","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.index","name":"index","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"index","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.index","name":"index","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"index","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.index","name":"index","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"index","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.index","name":"index","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"index","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.index","name":"index","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"index","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"index","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"index","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"index","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"int_":{".class":"SymbolTableNode","cross_ref":"numpy.int_","kind":"Gdef","module_hidden":true,"module_public":false},"isalnum":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.isalnum","name":"isalnum","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isalnum","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isalpha":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.isalpha","name":"isalpha","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isalpha","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isdecimal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.isdecimal","name":"isdecimal","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isdecimal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isdigit":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.isdigit","name":"isdigit","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isdigit","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"islower":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.islower","name":"islower","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"islower","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isnumeric":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.isnumeric","name":"isnumeric","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isnumeric","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isspace":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.isspace","name":"isspace","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"istitle":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.istitle","name":"istitle","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"istitle","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isupper":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.isupper","name":"isupper","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isupper","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"join":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.join","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["sep","seq"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.join","name":"join","original_first_arg":"sep","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["sep","seq"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"join","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.join","name":"join","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["sep","seq"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"join","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["sep","seq"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.join","name":"join","original_first_arg":"sep","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["sep","seq"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"join","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.join","name":"join","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["sep","seq"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"join","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["sep","seq"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.join","name":"join","original_first_arg":"sep","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["sep","seq"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"join","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.join","name":"join","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["sep","seq"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"join","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["sep","seq"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.join","name":"join","original_first_arg":"sep","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["sep","seq"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"join","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.join","name":"join","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["sep","seq"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"join","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["sep","seq"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"join","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["sep","seq"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"join","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["sep","seq"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"join","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["sep","seq"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"join","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"less":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.less","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.less","name":"less","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.less","name":"less","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.less","name":"less","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.less","name":"less","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.less","name":"less","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.less","name":"less","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"less_equal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.less_equal","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.less_equal","name":"less_equal","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.less_equal","name":"less_equal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.less_equal","name":"less_equal","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.less_equal","name":"less_equal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.less_equal","name":"less_equal","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.less_equal","name":"less_equal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"ljust":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.ljust","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.ljust","name":"ljust","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ljust","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.ljust","name":"ljust","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ljust","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.ljust","name":"ljust","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ljust","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.ljust","name":"ljust","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ljust","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.ljust","name":"ljust","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ljust","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.ljust","name":"ljust","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ljust","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.ljust","name":"ljust","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ljust","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.ljust","name":"ljust","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ljust","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ljust","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ljust","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ljust","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ljust","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"lower":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.lower","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.lower","name":"lower","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lower","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.lower","name":"lower","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lower","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.lower","name":"lower","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lower","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.lower","name":"lower","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lower","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.lower","name":"lower","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lower","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.lower","name":"lower","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lower","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.lower","name":"lower","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lower","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.lower","name":"lower","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lower","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lower","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lower","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lower","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lower","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"lstrip":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.lstrip","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","chars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.lstrip","name":"lstrip","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.lstrip","name":"lstrip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","chars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.lstrip","name":"lstrip","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.lstrip","name":"lstrip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","chars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.lstrip","name":"lstrip","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.lstrip","name":"lstrip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","chars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.lstrip","name":"lstrip","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.lstrip","name":"lstrip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"mod":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.mod","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.mod","name":"mod","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","value"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.mod","name":"mod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","value"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.mod","name":"mod","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","value"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.mod","name":"mod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","value"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.mod","name":"mod","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","value"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mod","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.mod","name":"mod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","value"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mod","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.mod","name":"mod","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","value"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mod","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.mod","name":"mod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","value"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mod","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","value"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","value"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","value"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mod","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","value"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mod","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"multiply":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.multiply","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","i"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.multiply","name":"multiply","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","i"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"multiply","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.multiply","name":"multiply","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","i"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"multiply","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","i"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.multiply","name":"multiply","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","i"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"multiply","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.multiply","name":"multiply","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","i"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"multiply","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","i"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.multiply","name":"multiply","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","i"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"multiply","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.multiply","name":"multiply","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","i"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"multiply","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","i"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.multiply","name":"multiply","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","i"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"multiply","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.multiply","name":"multiply","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","i"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"multiply","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","i"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"multiply","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","i"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"multiply","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","i"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"multiply","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","i"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"multiply","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"ndarray":{".class":"SymbolTableNode","cross_ref":"numpy.ndarray","kind":"Gdef","module_hidden":true,"module_public":false},"not_equal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.not_equal","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.not_equal","name":"not_equal","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"not_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.not_equal","name":"not_equal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"not_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.not_equal","name":"not_equal","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"not_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.not_equal","name":"not_equal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"not_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.not_equal","name":"not_equal","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"not_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.not_equal","name":"not_equal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"not_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"not_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"not_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"not_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"object_":{".class":"SymbolTableNode","cross_ref":"numpy.object_","kind":"Gdef","module_hidden":true,"module_public":false},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false},"partition":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.partition","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","sep"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.partition","name":"partition","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.partition","name":"partition","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","sep"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.partition","name":"partition","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.partition","name":"partition","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","sep"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.partition","name":"partition","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.partition","name":"partition","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","sep"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.partition","name":"partition","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.partition","name":"partition","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"replace":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.replace","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["a","old","new","count"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.replace","name":"replace","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","old","new","count"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.replace","name":"replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","old","new","count"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["a","old","new","count"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.replace","name":"replace","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","old","new","count"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.replace","name":"replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","old","new","count"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["a","old","new","count"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.replace","name":"replace","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","old","new","count"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.replace","name":"replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","old","new","count"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["a","old","new","count"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.replace","name":"replace","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","old","new","count"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.replace","name":"replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","old","new","count"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","old","new","count"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","old","new","count"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","old","new","count"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","old","new","count"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"rfind":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.rfind","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.rfind","name":"rfind","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rfind","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.rfind","name":"rfind","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rfind","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.rfind","name":"rfind","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rfind","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.rfind","name":"rfind","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rfind","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.rfind","name":"rfind","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rfind","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.rfind","name":"rfind","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rfind","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rfind","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rfind","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rfind","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"rindex":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.rindex","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.rindex","name":"rindex","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rindex","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.rindex","name":"rindex","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rindex","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.rindex","name":"rindex","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rindex","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.rindex","name":"rindex","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rindex","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.rindex","name":"rindex","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rindex","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.rindex","name":"rindex","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rindex","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rindex","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rindex","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rindex","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"rjust":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.rjust","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.rjust","name":"rjust","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rjust","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.rjust","name":"rjust","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rjust","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.rjust","name":"rjust","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rjust","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.rjust","name":"rjust","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rjust","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.rjust","name":"rjust","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rjust","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.rjust","name":"rjust","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rjust","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.rjust","name":"rjust","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rjust","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.rjust","name":"rjust","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rjust","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rjust","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rjust","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rjust","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rjust","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"rpartition":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.rpartition","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","sep"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.rpartition","name":"rpartition","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rpartition","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.rpartition","name":"rpartition","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rpartition","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","sep"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.rpartition","name":"rpartition","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rpartition","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.rpartition","name":"rpartition","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rpartition","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","sep"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.rpartition","name":"rpartition","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rpartition","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.rpartition","name":"rpartition","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rpartition","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","sep"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.rpartition","name":"rpartition","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rpartition","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.rpartition","name":"rpartition","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rpartition","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rpartition","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rpartition","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rpartition","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rpartition","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"rsplit":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.rsplit","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["a","sep","maxsplit"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.rsplit","name":"rsplit","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","sep","maxsplit"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rsplit","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.rsplit","name":"rsplit","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","sep","maxsplit"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rsplit","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["a","sep","maxsplit"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.rsplit","name":"rsplit","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","sep","maxsplit"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rsplit","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.rsplit","name":"rsplit","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","sep","maxsplit"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rsplit","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["a","sep","maxsplit"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.rsplit","name":"rsplit","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","sep","maxsplit"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rsplit","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.rsplit","name":"rsplit","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","sep","maxsplit"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rsplit","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["a","sep","maxsplit"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.rsplit","name":"rsplit","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","sep","maxsplit"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rsplit","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.rsplit","name":"rsplit","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","sep","maxsplit"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rsplit","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","sep","maxsplit"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rsplit","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","sep","maxsplit"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rsplit","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","sep","maxsplit"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rsplit","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","sep","maxsplit"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rsplit","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"rstrip":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.rstrip","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","chars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.rstrip","name":"rstrip","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.rstrip","name":"rstrip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","chars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.rstrip","name":"rstrip","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.rstrip","name":"rstrip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","chars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.rstrip","name":"rstrip","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.rstrip","name":"rstrip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","chars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.rstrip","name":"rstrip","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.rstrip","name":"rstrip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"split":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.split","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["a","sep","maxsplit"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.split","name":"split","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","sep","maxsplit"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"split","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.split","name":"split","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","sep","maxsplit"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"split","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["a","sep","maxsplit"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.split","name":"split","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","sep","maxsplit"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"split","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.split","name":"split","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","sep","maxsplit"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"split","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["a","sep","maxsplit"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.split","name":"split","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","sep","maxsplit"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"split","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.split","name":"split","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","sep","maxsplit"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"split","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["a","sep","maxsplit"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.split","name":"split","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","sep","maxsplit"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"split","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.split","name":"split","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","sep","maxsplit"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"split","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","sep","maxsplit"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"split","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","sep","maxsplit"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"split","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","sep","maxsplit"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"split","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","sep","maxsplit"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"split","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"splitlines":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","keepends"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.splitlines","name":"splitlines","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","keepends"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"splitlines","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"startswith":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.startswith","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","prefix","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.startswith","name":"startswith","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","prefix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"startswith","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.startswith","name":"startswith","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","prefix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"startswith","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","prefix","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.startswith","name":"startswith","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","prefix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"startswith","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.startswith","name":"startswith","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","prefix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"startswith","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","prefix","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.startswith","name":"startswith","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","prefix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"startswith","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.startswith","name":"startswith","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","prefix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"startswith","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","prefix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"startswith","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","prefix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"startswith","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","prefix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"startswith","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"str_":{".class":"SymbolTableNode","cross_ref":"numpy.str_","kind":"Gdef","module_hidden":true,"module_public":false},"str_len":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["A"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.str_len","name":"str_len","original_first_arg":"A","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["A"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"str_len","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"strip":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.strip","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","chars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.strip","name":"strip","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.strip","name":"strip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","chars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.strip","name":"strip","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.strip","name":"strip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","chars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.strip","name":"strip","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strip","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.strip","name":"strip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strip","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","chars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.strip","name":"strip","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strip","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.strip","name":"strip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strip","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strip","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strip","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"swapcase":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.swapcase","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.swapcase","name":"swapcase","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"swapcase","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.swapcase","name":"swapcase","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"swapcase","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.swapcase","name":"swapcase","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"swapcase","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.swapcase","name":"swapcase","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"swapcase","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.swapcase","name":"swapcase","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"swapcase","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.swapcase","name":"swapcase","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"swapcase","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.swapcase","name":"swapcase","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"swapcase","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.swapcase","name":"swapcase","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"swapcase","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"swapcase","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"swapcase","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"swapcase","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"swapcase","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"title":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.title","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.title","name":"title","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"title","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.title","name":"title","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"title","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.title","name":"title","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"title","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.title","name":"title","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"title","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.title","name":"title","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"title","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.title","name":"title","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"title","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.title","name":"title","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"title","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.title","name":"title","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"title","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"title","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"title","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"title","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"title","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"translate":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.translate","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","table","deletechars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.translate","name":"translate","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","table","deletechars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"translate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.translate","name":"translate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","table","deletechars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"translate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","table","deletechars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.translate","name":"translate","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","table","deletechars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"translate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.translate","name":"translate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","table","deletechars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"translate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","table","deletechars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.translate","name":"translate","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","table","deletechars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"translate","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.translate","name":"translate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","table","deletechars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"translate","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","table","deletechars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.translate","name":"translate","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","table","deletechars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"translate","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.translate","name":"translate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","table","deletechars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"translate","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","table","deletechars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"translate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","table","deletechars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"translate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","table","deletechars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"translate","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","table","deletechars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"translate","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"upper":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.upper","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.upper","name":"upper","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"upper","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.upper","name":"upper","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"upper","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.upper","name":"upper","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"upper","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.upper","name":"upper","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"upper","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.upper","name":"upper","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"upper","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.upper","name":"upper","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"upper","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.upper","name":"upper","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"upper","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.upper","name":"upper","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"upper","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"upper","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"upper","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"upper","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"upper","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"zfill":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.defchararray.zfill","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","width"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.zfill","name":"zfill","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","width"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zfill","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.zfill","name":"zfill","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","width"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zfill","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","width"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.zfill","name":"zfill","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","width"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zfill","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.zfill","name":"zfill","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","width"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zfill","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","width"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.zfill","name":"zfill","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","width"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zfill","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.zfill","name":"zfill","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","width"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zfill","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","width"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.defchararray.zfill","name":"zfill","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","width"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zfill","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.defchararray.zfill","name":"zfill","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","width"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zfill","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","width"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zfill","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","width"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zfill","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","width"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zfill","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","width"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zfill","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.defchararray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_core/defchararray.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/defchararray.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/defchararray.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..72f3119aed7ce5a20313b34a164ce8bb4694d8e8 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/defchararray.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[17,18,1,4,6,1,1,1,1,1],"dep_prios":[5,5,5,5,5,5,30,30,30,30],"dependencies":["numpy._core.multiarray","numpy._typing","typing","typing_extensions","numpy","builtins","_frozen_importlib","abc","numpy._typing._array_like","numpy.dtypes"],"hash":"ebdc7d1e4e07171a81358ec081476f591e2711c5","id":"numpy._core.defchararray","ignore_all":true,"interface_hash":"863c681c9efb1adf120aa7705cd52c9c71247585","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_core/defchararray.pyi","plugin_data":null,"size":27984,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/einsumfunc.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/einsumfunc.data.json new file mode 100644 index 0000000000000000000000000000000000000000..d64951475124b1aa2bb49aa6f58785b5069ca14d --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/einsumfunc.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy._core.einsumfunc","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef","module_hidden":true,"module_public":false},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy._core.einsumfunc.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeBool_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeBool_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeComplex_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeComplex_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeFloat_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeFloat_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeInt_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeInt_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeObject_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeObject_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeUInt_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeUInt_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","name":"_ArrayT","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}},"_CastingSafe":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._core.einsumfunc._CastingSafe","name":"_CastingSafe","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}}},"_CastingUnsafe":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._core.einsumfunc._CastingUnsafe","name":"_CastingUnsafe","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}}},"_DTypeLikeBool":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._DTypeLikeBool","kind":"Gdef","module_hidden":true,"module_public":false},"_DTypeLikeComplex":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._DTypeLikeComplex","kind":"Gdef","module_hidden":true,"module_public":false},"_DTypeLikeComplex_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._DTypeLikeComplex_co","kind":"Gdef","module_hidden":true,"module_public":false},"_DTypeLikeFloat":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._DTypeLikeFloat","kind":"Gdef","module_hidden":true,"module_public":false},"_DTypeLikeInt":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._DTypeLikeInt","kind":"Gdef","module_hidden":true,"module_public":false},"_DTypeLikeObject":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._DTypeLikeObject","kind":"Gdef","module_hidden":true,"module_public":false},"_DTypeLikeUInt":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._DTypeLikeUInt","kind":"Gdef","module_hidden":true,"module_public":false},"_OptimizeKind":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._core.einsumfunc._OptimizeKind","name":"_OptimizeKind","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}}},"_OrderKACF":{".class":"SymbolTableNode","cross_ref":"numpy._OrderKACF","kind":"Gdef","module_hidden":true,"module_public":false},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy._core.einsumfunc.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.einsumfunc.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.einsumfunc.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.einsumfunc.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.einsumfunc.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.einsumfunc.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.einsumfunc.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"einsum":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.einsumfunc.einsum","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,5,5,5,5,5],"arg_names":[null,"operands","out","dtype","order","casting","optimize"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.einsumfunc.einsum","name":"einsum","original_first_arg":"subscripts","type":{".class":"CallableType","arg_kinds":[0,2,5,5,5,5,5],"arg_names":[null,"operands","out","dtype","order","casting","optimize"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.einsumfunc.einsum","name":"einsum","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,2,5,5,5,5,5],"arg_names":[null,"operands","out","dtype","order","casting","optimize"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,5,5,5,5,5],"arg_names":[null,"operands","out","dtype","order","casting","optimize"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.einsumfunc.einsum","name":"einsum","original_first_arg":"subscripts","type":{".class":"CallableType","arg_kinds":[0,2,5,5,5,5,5],"arg_names":[null,"operands","out","dtype","order","casting","optimize"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.einsumfunc.einsum","name":"einsum","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,2,5,5,5,5,5],"arg_names":[null,"operands","out","dtype","order","casting","optimize"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,5,5,5,5,5],"arg_names":[null,"operands","out","dtype","order","casting","optimize"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.einsumfunc.einsum","name":"einsum","original_first_arg":"subscripts","type":{".class":"CallableType","arg_kinds":[0,2,5,5,5,5,5],"arg_names":[null,"operands","out","dtype","order","casting","optimize"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.einsumfunc.einsum","name":"einsum","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,2,5,5,5,5,5],"arg_names":[null,"operands","out","dtype","order","casting","optimize"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,5,5,5,5,5],"arg_names":[null,"operands","out","dtype","order","casting","optimize"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.einsumfunc.einsum","name":"einsum","original_first_arg":"subscripts","type":{".class":"CallableType","arg_kinds":[0,2,5,5,5,5,5],"arg_names":[null,"operands","out","dtype","order","casting","optimize"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.einsumfunc.einsum","name":"einsum","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,2,5,5,5,5,5],"arg_names":[null,"operands","out","dtype","order","casting","optimize"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,5,5,5,5,5],"arg_names":[null,"operands","out","dtype","order","casting","optimize"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.einsumfunc.einsum","name":"einsum","original_first_arg":"subscripts","type":{".class":"CallableType","arg_kinds":[0,2,5,5,5,5,5],"arg_names":[null,"operands","out","dtype","order","casting","optimize"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.einsumfunc.einsum","name":"einsum","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,2,5,5,5,5,5],"arg_names":[null,"operands","out","dtype","order","casting","optimize"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,3,5,5,5,5],"arg_names":[null,"operands","casting","dtype","out","order","optimize"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.einsumfunc.einsum","name":"einsum","original_first_arg":"subscripts","type":{".class":"CallableType","arg_kinds":[0,2,3,5,5,5,5],"arg_names":[null,"operands","casting","dtype","out","order","optimize"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.einsumfunc.einsum","name":"einsum","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,2,3,5,5,5,5],"arg_names":[null,"operands","casting","dtype","out","order","optimize"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,3,5,5,5,5],"arg_names":[null,"operands","out","dtype","order","casting","optimize"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.einsumfunc.einsum","name":"einsum","original_first_arg":"subscripts","type":{".class":"CallableType","arg_kinds":[0,2,3,5,5,5,5],"arg_names":[null,"operands","out","dtype","order","casting","optimize"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.einsumfunc.einsum#6","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.einsumfunc.einsum#6","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.einsumfunc.einsum#6","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.einsumfunc.einsum","name":"einsum","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,2,3,5,5,5,5],"arg_names":[null,"operands","out","dtype","order","casting","optimize"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.einsumfunc.einsum#6","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.einsumfunc.einsum#6","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.einsumfunc.einsum#6","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,3,3,5,5,5],"arg_names":[null,"operands","out","casting","dtype","order","optimize"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.einsumfunc.einsum","name":"einsum","original_first_arg":"subscripts","type":{".class":"CallableType","arg_kinds":[0,2,3,3,5,5,5],"arg_names":[null,"operands","out","casting","dtype","order","optimize"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.einsumfunc.einsum#7","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.einsumfunc.einsum#7","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.einsumfunc.einsum#7","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.einsumfunc.einsum","name":"einsum","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,2,3,3,5,5,5],"arg_names":[null,"operands","out","casting","dtype","order","optimize"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.einsumfunc.einsum#7","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.einsumfunc.einsum#7","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.einsumfunc.einsum#7","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,5,5,5,5,5],"arg_names":[null,"operands","out","dtype","order","casting","optimize"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.einsumfunc.einsum","name":"einsum","original_first_arg":"subscripts","type":{".class":"CallableType","arg_kinds":[0,2,5,5,5,5,5],"arg_names":[null,"operands","out","dtype","order","casting","optimize"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.einsumfunc.einsum","name":"einsum","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,2,5,5,5,5,5],"arg_names":[null,"operands","out","dtype","order","casting","optimize"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,3,5,5,5,5],"arg_names":[null,"operands","casting","dtype","out","order","optimize"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.einsumfunc.einsum","name":"einsum","original_first_arg":"subscripts","type":{".class":"CallableType","arg_kinds":[0,2,3,5,5,5,5],"arg_names":[null,"operands","casting","dtype","out","order","optimize"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.einsumfunc.einsum","name":"einsum","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,2,3,5,5,5,5],"arg_names":[null,"operands","casting","dtype","out","order","optimize"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,3,5,5,5,5],"arg_names":[null,"operands","out","dtype","order","casting","optimize"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.einsumfunc.einsum","name":"einsum","original_first_arg":"subscripts","type":{".class":"CallableType","arg_kinds":[0,2,3,5,5,5,5],"arg_names":[null,"operands","out","dtype","order","casting","optimize"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.einsumfunc.einsum#10","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.einsumfunc.einsum#10","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.einsumfunc.einsum#10","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.einsumfunc.einsum","name":"einsum","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,2,3,5,5,5,5],"arg_names":[null,"operands","out","dtype","order","casting","optimize"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.einsumfunc.einsum#10","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.einsumfunc.einsum#10","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.einsumfunc.einsum#10","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,3,3,5,5,5],"arg_names":[null,"operands","out","casting","dtype","order","optimize"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.einsumfunc.einsum","name":"einsum","original_first_arg":"subscripts","type":{".class":"CallableType","arg_kinds":[0,2,3,3,5,5,5],"arg_names":[null,"operands","out","casting","dtype","order","optimize"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.einsumfunc.einsum","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.einsumfunc.einsum","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.einsumfunc.einsum","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.einsumfunc.einsum","name":"einsum","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,2,3,3,5,5,5],"arg_names":[null,"operands","out","casting","dtype","order","optimize"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.einsumfunc.einsum","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.einsumfunc.einsum","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.einsumfunc.einsum","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,2,5,5,5,5,5],"arg_names":[null,"operands","out","dtype","order","casting","optimize"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,2,5,5,5,5,5],"arg_names":[null,"operands","out","dtype","order","casting","optimize"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,2,5,5,5,5,5],"arg_names":[null,"operands","out","dtype","order","casting","optimize"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,2,5,5,5,5,5],"arg_names":[null,"operands","out","dtype","order","casting","optimize"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,2,5,5,5,5,5],"arg_names":[null,"operands","out","dtype","order","casting","optimize"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,2,3,5,5,5,5],"arg_names":[null,"operands","casting","dtype","out","order","optimize"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,2,3,5,5,5,5],"arg_names":[null,"operands","out","dtype","order","casting","optimize"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.einsumfunc.einsum#6","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.einsumfunc.einsum#6","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.einsumfunc.einsum#6","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,2,3,3,5,5,5],"arg_names":[null,"operands","out","casting","dtype","order","optimize"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.einsumfunc.einsum#7","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.einsumfunc.einsum#7","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.einsumfunc.einsum#7","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,2,5,5,5,5,5],"arg_names":[null,"operands","out","dtype","order","casting","optimize"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,2,3,5,5,5,5],"arg_names":[null,"operands","casting","dtype","out","order","optimize"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,2,3,5,5,5,5],"arg_names":[null,"operands","out","dtype","order","casting","optimize"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.einsumfunc.einsum#10","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.einsumfunc.einsum#10","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.einsumfunc.einsum#10","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,2,3,3,5,5,5],"arg_names":[null,"operands","out","casting","dtype","order","optimize"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.einsumfunc.einsum","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.einsumfunc.einsum","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.einsumfunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.einsumfunc.einsum","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}]}}},"einsum_path":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,5,5],"arg_names":[null,"operands","optimize","einsum_call"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.einsumfunc.einsum_path","name":"einsum_path","original_first_arg":"subscripts","type":{".class":"CallableType","arg_kinds":[0,2,5,5],"arg_names":[null,"operands","optimize","einsum_call"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._core.einsumfunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"einsum_path","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"},"builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"number":{".class":"SymbolTableNode","cross_ref":"numpy.number","kind":"Gdef","module_hidden":true,"module_public":false},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_core/einsumfunc.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/einsumfunc.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/einsumfunc.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..c0aa42fa54feb1a2b7fcee9cd4d2a4a14a628377 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/einsumfunc.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,6,2,4,1,1,1],"dep_prios":[5,5,5,5,5,30,30],"dependencies":["collections.abc","numpy._typing","typing","numpy","builtins","_frozen_importlib","abc"],"hash":"7085cf73bc6078be285ac2b3c4ade484dc33f949","id":"numpy._core.einsumfunc","ignore_all":true,"interface_hash":"5f01ee5a75dc8d1977fad115382cafe3cbffc012","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_core/einsumfunc.pyi","plugin_data":null,"size":4893,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/fromnumeric.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/fromnumeric.data.json new file mode 100644 index 0000000000000000000000000000000000000000..eccb2771c922d11ec42f5f1c3710479f4dbefe14 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/fromnumeric.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy._core.fromnumeric","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"DTypeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like.DTypeLike","kind":"Gdef","module_hidden":true,"module_public":false},"Incomplete":{".class":"SymbolTableNode","cross_ref":"_typeshed.Incomplete","kind":"Gdef","module_hidden":true,"module_public":false},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"Never":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.Never","name":"Never","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.Never","source_any":null,"type_of_any":3}}},"Protocol":{".class":"SymbolTableNode","cross_ref":"typing.Protocol","kind":"Gdef","module_hidden":true,"module_public":false},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef","module_hidden":true,"module_public":false},"SupportsIndex":{".class":"SymbolTableNode","cross_ref":"typing.SupportsIndex","kind":"Gdef","module_hidden":true,"module_public":false},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.TypeAlias","source_any":null,"type_of_any":3}}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"_AnyShape":{".class":"SymbolTableNode","cross_ref":"numpy._typing._shape._AnyShape","kind":"Gdef","module_hidden":true,"module_public":false},"_AnyShapeT":{".class":"SymbolTableNode","cross_ref":"numpy._AnyShapeT","kind":"Gdef","module_hidden":true,"module_public":false},"_Array1D":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._core.fromnumeric._Array1D","name":"_Array1D","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.TypeAlias","source_any":null,"type_of_any":3}}},"_ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeBool_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeBool_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeComplex_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeComplex_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeFloat_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeFloat_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeInt":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeInt","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeInt_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeInt_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeObject_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeObject_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeUInt_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeUInt_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","name":"_ArrayT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}},"_BoolLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._BoolLike_co","kind":"Gdef","module_hidden":true,"module_public":false},"_BoolOrIntArrayT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","name":"_BoolOrIntArrayT","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}},"_CastingKind":{".class":"SymbolTableNode","cross_ref":"numpy._CastingKind","kind":"Gdef","module_hidden":true,"module_public":false},"_ComplexLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._ComplexLike_co","kind":"Gdef","module_hidden":true,"module_public":false},"_DTypeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._DTypeLike","kind":"Gdef","module_hidden":true,"module_public":false},"_IntLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._IntLike_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ModeKind":{".class":"SymbolTableNode","cross_ref":"numpy._ModeKind","kind":"Gdef","module_hidden":true,"module_public":false},"_NestedSequence":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nested_sequence._NestedSequence","kind":"Gdef","module_hidden":true,"module_public":false},"_NoValueType":{".class":"SymbolTableNode","cross_ref":"numpy._globals._NoValueType","kind":"Gdef","module_hidden":true,"module_public":false},"_NumberLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._NumberLike_co","kind":"Gdef","module_hidden":true,"module_public":false},"_NumberOrObjectT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._NumberOrObjectT","name":"_NumberOrObjectT","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0}},"_OrderACF":{".class":"SymbolTableNode","cross_ref":"numpy._OrderACF","kind":"Gdef","module_hidden":true,"module_public":false},"_OrderKACF":{".class":"SymbolTableNode","cross_ref":"numpy._OrderKACF","kind":"Gdef","module_hidden":true,"module_public":false},"_PartitionKind":{".class":"SymbolTableNode","cross_ref":"numpy._PartitionKind","kind":"Gdef","module_hidden":true,"module_public":false},"_PyArray":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._core.fromnumeric._PyArray","name":"_PyArray","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.TypeAlias","source_any":null,"type_of_any":3}}},"_PyScalar":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._core.fromnumeric._PyScalar","name":"_PyScalar","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.TypeAlias","source_any":null,"type_of_any":3}}},"_ScalarLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._ScalarLike_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ScalarT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","name":"_ScalarT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},"_ShapeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._shape._ShapeLike","kind":"Gdef","module_hidden":true,"module_public":false},"_ShapeT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ShapeT","name":"_ShapeT","upper_bound":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},"values":[],"variance":0}},"_ShapeT_co":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ShapeT_co","name":"_ShapeT_co","upper_bound":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},"values":[],"variance":1}},"_SortKind":{".class":"SymbolTableNode","cross_ref":"numpy._SortKind","kind":"Gdef","module_hidden":true,"module_public":false},"_SortSide":{".class":"SymbolTableNode","cross_ref":"numpy._SortSide","kind":"Gdef","module_hidden":true,"module_public":false},"_SupportsShape":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._core.fromnumeric._SupportsShape","name":"_SupportsShape","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.fromnumeric._SupportsShape","upper_bound":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy._core.fromnumeric._SupportsShape","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy._core.fromnumeric","mro":["numpy._core.fromnumeric._SupportsShape","builtins.object"],"names":{".class":"SymbolTable","shape":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._core.fromnumeric._SupportsShape.shape","name":"shape","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.fromnumeric._SupportsShape","upper_bound":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.fromnumeric._SupportsShape"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shape of _SupportsShape","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.fromnumeric._SupportsShape","upper_bound":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric._SupportsShape.shape","name":"shape","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.fromnumeric._SupportsShape","upper_bound":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.fromnumeric._SupportsShape"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shape of _SupportsShape","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.fromnumeric._SupportsShape","upper_bound":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._SupportsShape.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.fromnumeric._SupportsShape","upper_bound":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.fromnumeric._SupportsShape"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_ShapeT_co"],"typeddict_type":null}},"_T":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._T","name":"_T","upper_bound":"builtins.object","values":[],"variance":0}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy._core.fromnumeric.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.fromnumeric.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.fromnumeric.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.fromnumeric.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.fromnumeric.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.fromnumeric.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.fromnumeric.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"all":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.all","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","out","keepdims","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.all","name":"all","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.int","value":0},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"all","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.all","name":"all","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.int","value":0},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"all","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","out","keepdims","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.all","name":"all","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"all","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.all","name":"all","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"all","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,5],"arg_names":["a","axis","out","keepdims","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.all","name":"all","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,1,5],"arg_names":["a","axis","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.all#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"all","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.all#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.all#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.all","name":"all","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,5],"arg_names":["a","axis","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.all#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"all","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.all#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.all#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3,5,5],"arg_names":["a","axis","out","keepdims","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.all","name":"all","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,3,5,5],"arg_names":["a","axis","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.all","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"all","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.all","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.all","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.all","name":"all","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3,5,5],"arg_names":["a","axis","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.all","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"all","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.all","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.all","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.int","value":0},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"all","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"all","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,5],"arg_names":["a","axis","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.all#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"all","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.all#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.all#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5,5],"arg_names":["a","axis","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.all","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"all","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.all","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.all","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"amax":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.amax","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1],"arg_names":["a","axis","out","keepdims","initial","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.amax","name":"amax","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"amax","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.amax#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.amax#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.amax","name":"amax","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"amax","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.amax#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.amax#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1],"arg_names":["a","axis","out","keepdims","initial","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.amax","name":"amax","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"amax","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.amax","name":"amax","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"amax","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1],"arg_names":["a","axis","out","keepdims","initial","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.amax","name":"amax","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amax#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"amax","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amax#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amax#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.amax","name":"amax","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amax#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"amax","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amax#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amax#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3,5,5,5],"arg_names":["a","axis","out","keepdims","initial","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.amax","name":"amax","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,3,5,5,5],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amax","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"amax","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amax","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amax","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.amax","name":"amax","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3,5,5,5],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amax","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"amax","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amax","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amax","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1,1],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"amax","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.amax#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.amax#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"amax","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amax#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"amax","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amax#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amax#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5,5,5],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amax","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"amax","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amax","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amax","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"amin":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.amin","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1],"arg_names":["a","axis","out","keepdims","initial","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.amin","name":"amin","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"amin","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.amin#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.amin#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.amin","name":"amin","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"amin","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.amin#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.amin#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1],"arg_names":["a","axis","out","keepdims","initial","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.amin","name":"amin","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"amin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.amin","name":"amin","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"amin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1],"arg_names":["a","axis","out","keepdims","initial","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.amin","name":"amin","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amin#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"amin","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amin#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amin#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.amin","name":"amin","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amin#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"amin","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amin#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amin#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3,5,5,5],"arg_names":["a","axis","out","keepdims","initial","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.amin","name":"amin","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,3,5,5,5],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amin","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"amin","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amin","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amin","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.amin","name":"amin","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3,5,5,5],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amin","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"amin","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amin","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amin","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1,1],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"amin","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.amin#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.amin#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"amin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amin#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"amin","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amin#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amin#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5,5,5],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amin","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"amin","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amin","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amin","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"any":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.any","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","out","keepdims","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.any","name":"any","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.int","value":0},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"any","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.any","name":"any","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.int","value":0},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"any","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","out","keepdims","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.any","name":"any","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"any","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.any","name":"any","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"any","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,5],"arg_names":["a","axis","out","keepdims","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.any","name":"any","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,1,5],"arg_names":["a","axis","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.any#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"any","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.any#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.any#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.any","name":"any","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,5],"arg_names":["a","axis","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.any#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"any","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.any#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.any#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3,5,5],"arg_names":["a","axis","out","keepdims","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.any","name":"any","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,3,5,5],"arg_names":["a","axis","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.any","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"any","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.any","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.any","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.any","name":"any","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3,5,5],"arg_names":["a","axis","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.any","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"any","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.any","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.any","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.int","value":0},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"any","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"any","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,5],"arg_names":["a","axis","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.any#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"any","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.any#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.any#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5,5],"arg_names":["a","axis","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.any","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"any","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.any","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.any","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"argmax":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.argmax","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,5],"arg_names":["a","axis","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.argmax","name":"argmax","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmax","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.argmax","name":"argmax","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmax","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,5],"arg_names":["a","axis","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.argmax","name":"argmax","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmax","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.argmax","name":"argmax","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmax","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5],"arg_names":["a","axis","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.argmax","name":"argmax","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,5],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmax#2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmax","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmax#2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmax#2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.argmax","name":"argmax","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,5],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmax#2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmax","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmax#2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmax#2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3,5],"arg_names":["a","axis","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.argmax","name":"argmax","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmax","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmax","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmax","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmax","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.argmax","name":"argmax","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmax","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmax","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmax","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmax","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmax","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmax","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,5],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmax#2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmax","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmax#2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmax#2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmax","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmax","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmax","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmax","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}]}}},"argmin":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.argmin","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,5],"arg_names":["a","axis","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.argmin","name":"argmin","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmin","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.argmin","name":"argmin","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmin","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,5],"arg_names":["a","axis","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.argmin","name":"argmin","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.argmin","name":"argmin","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5],"arg_names":["a","axis","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.argmin","name":"argmin","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,5],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmin#2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmin","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmin#2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmin#2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.argmin","name":"argmin","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,5],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmin#2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmin","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmin#2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmin#2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3,5],"arg_names":["a","axis","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.argmin","name":"argmin","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmin","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmin","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmin","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmin","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.argmin","name":"argmin","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmin","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmin","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmin","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmin","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmin","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,5],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmin#2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmin","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmin#2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmin#2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmin","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmin","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmin","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmin","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}]}}},"argpartition":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["a","kth","axis","kind","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.argpartition","name":"argpartition","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","kth","axis","kind","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argpartition","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"argsort":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","kind","order","stable"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.argsort","name":"argsort","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","kind","order","stable"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argsort","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"around":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.around","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["a","decimals","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.around","name":"around","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","decimals","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"around","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.around","name":"around","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","decimals","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"around","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["a","decimals","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.around","name":"around","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","decimals","out"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._NumberOrObjectT","id":-1,"name":"_NumberOrObjectT","namespace":"numpy._core.fromnumeric.around#1","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0},"typing.SupportsIndex",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"around","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._NumberOrObjectT","id":-1,"name":"_NumberOrObjectT","namespace":"numpy._core.fromnumeric.around#1","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._NumberOrObjectT","id":-1,"name":"_NumberOrObjectT","namespace":"numpy._core.fromnumeric.around#1","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.around","name":"around","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","decimals","out"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._NumberOrObjectT","id":-1,"name":"_NumberOrObjectT","namespace":"numpy._core.fromnumeric.around#1","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0},"typing.SupportsIndex",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"around","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._NumberOrObjectT","id":-1,"name":"_NumberOrObjectT","namespace":"numpy._core.fromnumeric.around#1","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._NumberOrObjectT","id":-1,"name":"_NumberOrObjectT","namespace":"numpy._core.fromnumeric.around#1","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["a","decimals","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.around","name":"around","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","decimals","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"numpy.object_"],"uses_pep604_syntax":true},"typing.SupportsIndex",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"around","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.around","name":"around","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","decimals","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"numpy.object_"],"uses_pep604_syntax":true},"typing.SupportsIndex",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"around","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["a","decimals","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.around","name":"around","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","decimals","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"around","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.around","name":"around","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","decimals","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"around","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["a","decimals","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.around","name":"around","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","decimals","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"around","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._NumberOrObjectT","id":-1,"name":"_NumberOrObjectT","namespace":"numpy._core.fromnumeric.around#4","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.around","name":"around","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","decimals","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"around","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._NumberOrObjectT","id":-1,"name":"_NumberOrObjectT","namespace":"numpy._core.fromnumeric.around#4","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["a","decimals","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.around","name":"around","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","decimals","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"typing.SupportsIndex",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"around","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.around","name":"around","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","decimals","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"typing.SupportsIndex",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"around","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["a","decimals","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.around","name":"around","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["a","decimals","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"typing.SupportsIndex",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.around#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"around","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.around#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.around#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.around","name":"around","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["a","decimals","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"typing.SupportsIndex",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.around#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"around","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.around#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.around#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3],"arg_names":["a","decimals","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.around","name":"around","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,3],"arg_names":["a","decimals","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"typing.SupportsIndex",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.around","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"around","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.around","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.around","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.around","name":"around","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3],"arg_names":["a","decimals","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"typing.SupportsIndex",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.around","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"around","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.around","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.around","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","decimals","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"around","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","decimals","out"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._NumberOrObjectT","id":-1,"name":"_NumberOrObjectT","namespace":"numpy._core.fromnumeric.around#1","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0},"typing.SupportsIndex",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"around","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._NumberOrObjectT","id":-1,"name":"_NumberOrObjectT","namespace":"numpy._core.fromnumeric.around#1","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._NumberOrObjectT","id":-1,"name":"_NumberOrObjectT","namespace":"numpy._core.fromnumeric.around#1","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","decimals","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"numpy.object_"],"uses_pep604_syntax":true},"typing.SupportsIndex",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"around","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","decimals","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"around","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","decimals","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"around","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._NumberOrObjectT","id":-1,"name":"_NumberOrObjectT","namespace":"numpy._core.fromnumeric.around#4","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","decimals","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"typing.SupportsIndex",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"around","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["a","decimals","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"typing.SupportsIndex",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.around#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"around","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.around#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.around#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3],"arg_names":["a","decimals","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"typing.SupportsIndex",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.around","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"around","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.around","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.around","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"choose":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.choose","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","choices","out","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.choose","name":"choose","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","choices","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"choose","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.choose","name":"choose","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","choices","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"choose","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","choices","out","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.choose","name":"choose","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","choices","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"choose","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.choose#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.choose","name":"choose","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","choices","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"choose","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.choose#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","choices","out","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.choose","name":"choose","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","choices","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"choose","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.choose","name":"choose","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","choices","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"choose","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["a","choices","out","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.choose","name":"choose","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","choices","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.choose","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"choose","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.choose","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.choose","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.choose","name":"choose","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","choices","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.choose","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"choose","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.choose","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.choose","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","choices","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"choose","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","choices","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"choose","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.choose#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","choices","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"choose","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","choices","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.choose","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"choose","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.choose","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.choose","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"clip":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.clip","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,5,5,5,5,5,5,5,5],"arg_names":["a","a_min","a_max","out","min","max","dtype","where","order","subok","signature","casting"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.clip","name":"clip","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,1,5,5,5,5,5,5,5,5],"arg_names":["a","a_min","a_max","out","min","max","dtype","where","order","subok","signature","casting"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.clip#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"clip","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.clip#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.clip#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.clip","name":"clip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,5,5,5,5,5,5,5,5],"arg_names":["a","a_min","a_max","out","min","max","dtype","where","order","subok","signature","casting"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.clip#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"clip","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.clip#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.clip#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,5,5,5,5,5,5,5,5],"arg_names":["a","a_min","a_max","out","min","max","dtype","where","order","subok","signature","casting"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.clip","name":"clip","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,1,5,5,5,5,5,5,5,5],"arg_names":["a","a_min","a_max","out","min","max","dtype","where","order","subok","signature","casting"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"clip","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.clip","name":"clip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,5,5,5,5,5,5,5,5],"arg_names":["a","a_min","a_max","out","min","max","dtype","where","order","subok","signature","casting"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"clip","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,5,5,5,5,5,5,5,5],"arg_names":["a","a_min","a_max","out","min","max","dtype","where","order","subok","signature","casting"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.clip","name":"clip","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,1,5,5,5,5,5,5,5,5],"arg_names":["a","a_min","a_max","out","min","max","dtype","where","order","subok","signature","casting"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"clip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.clip#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.clip","name":"clip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,5,5,5,5,5,5,5,5],"arg_names":["a","a_min","a_max","out","min","max","dtype","where","order","subok","signature","casting"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"clip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.clip#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,5,5,5,5,5,5,5,5],"arg_names":["a","a_min","a_max","out","min","max","dtype","where","order","subok","signature","casting"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.clip","name":"clip","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,1,5,5,5,5,5,5,5,5],"arg_names":["a","a_min","a_max","out","min","max","dtype","where","order","subok","signature","casting"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"clip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.clip","name":"clip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,5,5,5,5,5,5,5,5],"arg_names":["a","a_min","a_max","out","min","max","dtype","where","order","subok","signature","casting"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"clip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,5,5,5,5,5,5,5,5],"arg_names":["a","a_min","a_max","out","min","max","dtype","where","order","subok","signature","casting"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.clip","name":"clip","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,0,5,5,5,5,5,5,5,5],"arg_names":["a","a_min","a_max","out","min","max","dtype","where","order","subok","signature","casting"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.clip#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"clip","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.clip#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.clip#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.clip","name":"clip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,5,5,5,5,5,5,5,5],"arg_names":["a","a_min","a_max","out","min","max","dtype","where","order","subok","signature","casting"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.clip#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"clip","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.clip#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.clip#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,5,5,3,5,5,5,5,5],"arg_names":["a","a_min","a_max","out","min","max","dtype","where","order","subok","signature","casting"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.clip","name":"clip","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,1,5,5,3,5,5,5,5,5],"arg_names":["a","a_min","a_max","out","min","max","dtype","where","order","subok","signature","casting"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"clip","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.clip","name":"clip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,5,5,3,5,5,5,5,5],"arg_names":["a","a_min","a_max","out","min","max","dtype","where","order","subok","signature","casting"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"clip","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,1,5,5,5,5,5,5,5,5],"arg_names":["a","a_min","a_max","out","min","max","dtype","where","order","subok","signature","casting"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.clip#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"clip","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.clip#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.clip#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,1,5,5,5,5,5,5,5,5],"arg_names":["a","a_min","a_max","out","min","max","dtype","where","order","subok","signature","casting"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"clip","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,5,5,5,5,5,5,5,5],"arg_names":["a","a_min","a_max","out","min","max","dtype","where","order","subok","signature","casting"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"clip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.clip#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,1,5,5,5,5,5,5,5,5],"arg_names":["a","a_min","a_max","out","min","max","dtype","where","order","subok","signature","casting"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"clip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,5,5,5,5,5,5,5,5],"arg_names":["a","a_min","a_max","out","min","max","dtype","where","order","subok","signature","casting"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.clip#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"clip","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.clip#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.clip#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,1,5,5,3,5,5,5,5,5],"arg_names":["a","a_min","a_max","out","min","max","dtype","where","order","subok","signature","casting"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"clip","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"complexfloating":{".class":"SymbolTableNode","cross_ref":"numpy.complexfloating","kind":"Gdef","module_hidden":true,"module_public":false},"compress":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.compress","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["condition","a","axis","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.compress","name":"compress","original_first_arg":"condition","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["condition","a","axis","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"compress","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.compress#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.compress","name":"compress","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["condition","a","axis","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"compress","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.compress#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["condition","a","axis","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.compress","name":"compress","original_first_arg":"condition","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["condition","a","axis","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"compress","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.compress","name":"compress","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["condition","a","axis","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"compress","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["condition","a","axis","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.compress","name":"compress","original_first_arg":"condition","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["condition","a","axis","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.compress#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"compress","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.compress#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.compress#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.compress","name":"compress","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["condition","a","axis","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.compress#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"compress","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.compress#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.compress#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,3],"arg_names":["condition","a","axis","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.compress","name":"compress","original_first_arg":"condition","type":{".class":"CallableType","arg_kinds":[0,0,1,3],"arg_names":["condition","a","axis","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.compress","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"compress","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.compress","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.compress","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.compress","name":"compress","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,3],"arg_names":["condition","a","axis","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.compress","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"compress","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.compress","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.compress","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["condition","a","axis","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"compress","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.compress#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["condition","a","axis","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"compress","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["condition","a","axis","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.compress#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"compress","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.compress#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.compress#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,3],"arg_names":["condition","a","axis","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.compress","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"compress","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.compress","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.compress","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"cumprod":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.cumprod","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.cumprod","name":"cumprod","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumprod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.cumprod","name":"cumprod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumprod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.cumprod","name":"cumprod","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumprod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.cumprod","name":"cumprod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumprod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.cumprod","name":"cumprod","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumprod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.cumprod","name":"cumprod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumprod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.cumprod","name":"cumprod","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumprod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.cumprod","name":"cumprod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumprod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.cumprod","name":"cumprod","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumprod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.cumprod","name":"cumprod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumprod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.cumprod","name":"cumprod","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumprod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.cumprod","name":"cumprod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumprod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["a","axis","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.cumprod","name":"cumprod","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumprod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.cumprod#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.cumprod","name":"cumprod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumprod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.cumprod#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3,5],"arg_names":["a","axis","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.cumprod","name":"cumprod","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumprod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.cumprod#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.cumprod","name":"cumprod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumprod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.cumprod#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.cumprod","name":"cumprod","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumprod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.cumprod","name":"cumprod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumprod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["a","axis","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.cumprod","name":"cumprod","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumprod#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumprod","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumprod#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumprod#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.cumprod","name":"cumprod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumprod#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumprod","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumprod#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumprod#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,3],"arg_names":["a","axis","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.cumprod","name":"cumprod","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,3],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumprod","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumprod","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumprod","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumprod","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.cumprod","name":"cumprod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,3],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumprod","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumprod","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumprod","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumprod","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumprod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumprod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumprod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumprod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumprod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumprod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumprod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.cumprod#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumprod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.cumprod#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumprod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumprod#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumprod","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumprod#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumprod#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,3],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumprod","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumprod","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumprod","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumprod","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"cumsum":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.cumsum","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.cumsum","name":"cumsum","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumsum","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.cumsum#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.cumsum","name":"cumsum","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumsum","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.cumsum#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.cumsum","name":"cumsum","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumsum","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.cumsum","name":"cumsum","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumsum","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["a","axis","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.cumsum","name":"cumsum","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumsum","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.cumsum#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.cumsum","name":"cumsum","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumsum","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.cumsum#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3,5],"arg_names":["a","axis","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.cumsum","name":"cumsum","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumsum","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.cumsum#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.cumsum","name":"cumsum","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumsum","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.cumsum#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.cumsum","name":"cumsum","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumsum","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.cumsum","name":"cumsum","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumsum","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["a","axis","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.cumsum","name":"cumsum","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumsum#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumsum","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumsum#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumsum#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.cumsum","name":"cumsum","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumsum#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumsum","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumsum#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumsum#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,3],"arg_names":["a","axis","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.cumsum","name":"cumsum","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,3],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumsum","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumsum","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumsum","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumsum","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.cumsum","name":"cumsum","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,3],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumsum","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumsum","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumsum","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumsum","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumsum","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.cumsum#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumsum","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumsum","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.cumsum#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumsum","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.cumsum#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumsum","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumsum#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumsum","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumsum#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumsum#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,3],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumsum","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumsum","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumsum","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumsum","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"cumulative_prod":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.cumulative_prod","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.cumulative_prod","name":"cumulative_prod","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_prod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.cumulative_prod","name":"cumulative_prod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_prod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.cumulative_prod","name":"cumulative_prod","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_prod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.cumulative_prod","name":"cumulative_prod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_prod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.cumulative_prod","name":"cumulative_prod","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_prod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.cumulative_prod","name":"cumulative_prod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_prod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.cumulative_prod","name":"cumulative_prod","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_prod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.cumulative_prod","name":"cumulative_prod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_prod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.cumulative_prod","name":"cumulative_prod","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_prod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.cumulative_prod","name":"cumulative_prod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_prod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.cumulative_prod","name":"cumulative_prod","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_prod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.cumulative_prod","name":"cumulative_prod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_prod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,3,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.cumulative_prod","name":"cumulative_prod","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,5,3,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_prod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.cumulative_prod#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.cumulative_prod","name":"cumulative_prod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,3,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_prod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.cumulative_prod#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.cumulative_prod","name":"cumulative_prod","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_prod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.cumulative_prod","name":"cumulative_prod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_prod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,3,5],"arg_names":[null,"axis","dtype","out","include_initial"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.cumulative_prod","name":"cumulative_prod","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,5,5,3,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumulative_prod","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_prod","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumulative_prod","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumulative_prod","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.cumulative_prod","name":"cumulative_prod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5,3,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumulative_prod","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_prod","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumulative_prod","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumulative_prod","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_prod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_prod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_prod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_prod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_prod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_prod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,5,3,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_prod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.cumulative_prod#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_prod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,5,5,3,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumulative_prod","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_prod","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumulative_prod","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumulative_prod","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"cumulative_sum":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.cumulative_sum","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.cumulative_sum","name":"cumulative_sum","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_sum","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.cumulative_sum#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.cumulative_sum","name":"cumulative_sum","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_sum","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.cumulative_sum#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.cumulative_sum","name":"cumulative_sum","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_sum","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.cumulative_sum","name":"cumulative_sum","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_sum","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,3,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.cumulative_sum","name":"cumulative_sum","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,5,3,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_sum","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.cumulative_sum#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.cumulative_sum","name":"cumulative_sum","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,3,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_sum","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.cumulative_sum#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.cumulative_sum","name":"cumulative_sum","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_sum","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.cumulative_sum","name":"cumulative_sum","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_sum","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,3,5],"arg_names":[null,"axis","dtype","out","include_initial"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.cumulative_sum","name":"cumulative_sum","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,5,5,3,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumulative_sum","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_sum","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumulative_sum","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumulative_sum","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.cumulative_sum","name":"cumulative_sum","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5,3,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumulative_sum","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_sum","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumulative_sum","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumulative_sum","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_sum","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.cumulative_sum#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_sum","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,5,3,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_sum","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.cumulative_sum#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_sum","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,5,5,3,5],"arg_names":[null,"axis","dtype","out","include_initial"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumulative_sum","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cumulative_sum","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumulative_sum","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumulative_sum","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"deprecated":{".class":"SymbolTableNode","cross_ref":"typing_extensions.deprecated","kind":"Gdef","module_hidden":true,"module_public":false},"diagonal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.diagonal","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["a","offset","axis1","axis2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.diagonal","name":"diagonal","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","offset","axis1","axis2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","typing.SupportsIndex","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"diagonal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.diagonal#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.diagonal","name":"diagonal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","offset","axis1","axis2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","typing.SupportsIndex","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"diagonal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.diagonal#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["a","offset","axis1","axis2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.diagonal","name":"diagonal","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","offset","axis1","axis2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","typing.SupportsIndex","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"diagonal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.diagonal","name":"diagonal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","offset","axis1","axis2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","typing.SupportsIndex","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"diagonal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","offset","axis1","axis2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","typing.SupportsIndex","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"diagonal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.diagonal#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","offset","axis1","axis2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","typing.SupportsIndex","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"diagonal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"float16":{".class":"SymbolTableNode","cross_ref":"numpy.float16","kind":"Gdef","module_hidden":true,"module_public":false},"floating":{".class":"SymbolTableNode","cross_ref":"numpy.floating","kind":"Gdef","module_hidden":true,"module_public":false},"generic":{".class":"SymbolTableNode","cross_ref":"numpy.generic","kind":"Gdef","module_hidden":true,"module_public":false},"int64":{".class":"SymbolTableNode","cross_ref":"numpy.int64","kind":"Gdef","module_hidden":true,"module_public":false},"int_":{".class":"SymbolTableNode","cross_ref":"numpy.int_","kind":"Gdef","module_hidden":true,"module_public":false},"intp":{".class":"SymbolTableNode","cross_ref":"numpy.intp","kind":"Gdef","module_hidden":true,"module_public":false},"matrix_transpose":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.matrix_transpose","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.matrix_transpose","name":"matrix_transpose","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"matrix_transpose","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.matrix_transpose#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.matrix_transpose","name":"matrix_transpose","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"matrix_transpose","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.matrix_transpose#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.matrix_transpose","name":"matrix_transpose","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"matrix_transpose","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.matrix_transpose","name":"matrix_transpose","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"matrix_transpose","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"matrix_transpose","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.matrix_transpose#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"matrix_transpose","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"max":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy._core.fromnumeric.max","name":"max","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1,1],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.amax#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.amax#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amax#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amax#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amax#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5,5,5],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amax","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amax","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amax","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"mean":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.mean","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.mean","name":"mean","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mean","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.mean","name":"mean","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mean","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.mean","name":"mean","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mean","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.mean","name":"mean","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mean","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.mean","name":"mean","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mean","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.mean","name":"mean","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mean","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.mean","name":"mean","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.mean#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mean","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.mean#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.mean#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.mean","name":"mean","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.mean#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mean","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.mean#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.mean#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,3,5,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.mean","name":"mean","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,3,5,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.mean#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mean","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.mean#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.mean#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.mean","name":"mean","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,3,5,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.mean#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mean","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.mean#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.mean#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.mean","name":"mean","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mean","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.mean#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.mean#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.mean","name":"mean","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mean","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.mean#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.mean#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3,5,5,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.mean","name":"mean","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,3,5,5,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mean","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.mean#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.mean#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.mean","name":"mean","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3,5,5,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mean","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.mean#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.mean#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.mean","name":"mean","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.int","value":1}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mean","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.mean#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.mean","name":"mean","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.int","value":1}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mean","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.mean#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,5,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.mean","name":"mean","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,1,5,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mean","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.mean#8","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.mean#8","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.mean","name":"mean","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,5,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mean","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.mean#8","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.mean#8","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3,5,5,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.mean","name":"mean","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,3,5,5,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mean","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.mean#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.mean#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.mean","name":"mean","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3,5,5,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mean","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.mean#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.mean#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.mean","name":"mean","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mean","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.mean","name":"mean","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mean","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mean","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mean","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mean","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.mean#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mean","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.mean#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.mean#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,3,5,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.mean#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mean","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.mean#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.mean#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mean","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.mean#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.mean#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5,5,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mean","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.mean#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.mean#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,0,0,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.int","value":1}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mean","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.mean#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,1,5,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mean","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.mean#8","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.mean#8","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5,5,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mean","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.mean#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.mean#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mean","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"min":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy._core.fromnumeric.min","name":"min","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1,1],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.amin#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.amin#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amin#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amin#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amin#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5,5,5],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amin","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amin","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amin","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"ndim":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.ndim","name":"ndim","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ndim","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"nonzero":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.nonzero","name":"nonzero","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nonzero","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"object_":{".class":"SymbolTableNode","cross_ref":"numpy.object_","kind":"Gdef","module_hidden":true,"module_public":false},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false},"partition":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.partition","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["a","kth","axis","kind","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.partition","name":"partition","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","kth","axis","kind","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.partition#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.partition","name":"partition","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","kth","axis","kind","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.partition#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["a","kth","axis","kind","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.partition","name":"partition","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","kth","axis","kind","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.partition","name":"partition","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","kth","axis","kind","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["a","kth","axis","kind","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.partition","name":"partition","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","kth","axis","kind","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.partition","name":"partition","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","kth","axis","kind","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","kth","axis","kind","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.partition#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","kth","axis","kind","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","kth","axis","kind","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"prod":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.prod","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.prod","name":"prod","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prod","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int_"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.prod","name":"prod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prod","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int_"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.prod","name":"prod","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prod","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.prod","name":"prod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prod","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.prod","name":"prod","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prod","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.prod","name":"prod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prod","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.prod","name":"prod","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prod","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.prod","name":"prod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prod","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.prod","name":"prod","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prod","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.prod","name":"prod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prod","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.prod","name":"prod","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prod","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.prod","name":"prod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prod","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.prod","name":"prod","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prod","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.prod#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.prod#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.prod","name":"prod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prod","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.prod#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.prod#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3,5,5,5,5],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.prod","name":"prod","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,3,5,5,5,5],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prod","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.prod#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.prod#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.prod","name":"prod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3,5,5,5,5],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prod","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.prod#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.prod#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.prod","name":"prod","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prod","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.prod","name":"prod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prod","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.prod","name":"prod","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.prod#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prod","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.prod#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.prod#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.prod","name":"prod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.prod#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prod","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.prod#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.prod#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,3,5,5,5],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.prod","name":"prod","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,3,5,5,5],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.prod","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prod","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.prod","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.prod","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.prod","name":"prod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,3,5,5,5],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.prod","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prod","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.prod","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.prod","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prod","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int_"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prod","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prod","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prod","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prod","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prod","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prod","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.prod#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.prod#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5,5,5,5],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prod","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.prod#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.prod#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prod","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.prod#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prod","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.prod#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.prod#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,3,5,5,5],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.prod","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prod","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.prod","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.prod","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"ptp":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.ptp","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["a","axis","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.ptp","name":"ptp","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ptp","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.ptp#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.ptp#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.ptp","name":"ptp","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ptp","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.ptp#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.ptp#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["a","axis","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.ptp","name":"ptp","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ptp","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.ptp","name":"ptp","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ptp","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["a","axis","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.ptp","name":"ptp","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.ptp#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ptp","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.ptp#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.ptp#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.ptp","name":"ptp","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.ptp#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ptp","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.ptp#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.ptp#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3,5],"arg_names":["a","axis","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.ptp","name":"ptp","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.ptp","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ptp","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.ptp","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.ptp","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.ptp","name":"ptp","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.ptp","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ptp","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.ptp","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.ptp","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ptp","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.ptp#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.ptp#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ptp","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.ptp#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ptp","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.ptp#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.ptp#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.ptp","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ptp","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.ptp","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.ptp","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"put":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["a","ind","v","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.put","name":"put","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","ind","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"put","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"ravel":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.ravel","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.ravel","name":"ravel","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ravel","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.ravel#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.ravel","name":"ravel","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ravel","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.ravel#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.ravel","name":"ravel","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","order"],"arg_types":[{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ravel","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.ravel","name":"ravel","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","order"],"arg_types":[{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ravel","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.ravel","name":"ravel","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","order"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ravel","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.ravel","name":"ravel","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","order"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ravel","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.ravel","name":"ravel","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","order"],"arg_types":[{".class":"UnionType","items":["builtins.bool",{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ravel","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.ravel","name":"ravel","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","order"],"arg_types":[{".class":"UnionType","items":["builtins.bool",{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ravel","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.ravel","name":"ravel","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","order"],"arg_types":[{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ravel","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.ravel","name":"ravel","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","order"],"arg_types":[{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ravel","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.ravel","name":"ravel","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","order"],"arg_types":[{".class":"UnionType","items":["builtins.float",{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ravel","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.ravel","name":"ravel","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","order"],"arg_types":[{".class":"UnionType","items":["builtins.float",{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ravel","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.ravel","name":"ravel","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","order"],"arg_types":[{".class":"UnionType","items":["builtins.complex",{".class":"Instance","args":["builtins.complex"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ravel","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.ravel","name":"ravel","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","order"],"arg_types":[{".class":"UnionType","items":["builtins.complex",{".class":"Instance","args":["builtins.complex"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ravel","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.ravel","name":"ravel","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ravel","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.ravel","name":"ravel","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ravel","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ravel","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.ravel#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","order"],"arg_types":[{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ravel","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","order"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ravel","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","order"],"arg_types":[{".class":"UnionType","items":["builtins.bool",{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ravel","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","order"],"arg_types":[{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ravel","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","order"],"arg_types":[{".class":"UnionType","items":["builtins.float",{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ravel","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","order"],"arg_types":[{".class":"UnionType","items":["builtins.complex",{".class":"Instance","args":["builtins.complex"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ravel","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ravel","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"repeat":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.repeat","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","repeats","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.repeat","name":"repeat","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","repeats","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"repeat","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.repeat#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.repeat#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.repeat","name":"repeat","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","repeats","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"repeat","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.repeat#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.repeat#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["a","repeats","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.repeat","name":"repeat","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["a","repeats","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"repeat","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.repeat#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.repeat","name":"repeat","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["a","repeats","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"repeat","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.repeat#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","repeats","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.repeat","name":"repeat","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","repeats","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"repeat","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.repeat","name":"repeat","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","repeats","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"repeat","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["a","repeats","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.repeat","name":"repeat","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["a","repeats","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"repeat","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.repeat","name":"repeat","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["a","repeats","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"repeat","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","repeats","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"repeat","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.repeat#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.repeat#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["a","repeats","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"repeat","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.repeat#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","repeats","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"repeat","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["a","repeats","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"repeat","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"reshape":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.reshape","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,5],"arg_names":[null,"shape","order","copy"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.reshape","name":"reshape","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,5],"arg_names":[null,"shape","order","copy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reshape","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.reshape#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.reshape#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.reshape","name":"reshape","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,5],"arg_names":[null,"shape","order","copy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reshape","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.reshape#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.reshape#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,5],"arg_names":[null,"shape","order","copy"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.reshape","name":"reshape","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,5],"arg_names":[null,"shape","order","copy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-2,"name":"_AnyShapeT","namespace":"numpy._core.fromnumeric.reshape#1","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reshape","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-2,"name":"_AnyShapeT","namespace":"numpy._core.fromnumeric.reshape#1","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.reshape#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.reshape#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-2,"name":"_AnyShapeT","namespace":"numpy._core.fromnumeric.reshape#1","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.reshape","name":"reshape","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,5],"arg_names":[null,"shape","order","copy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-2,"name":"_AnyShapeT","namespace":"numpy._core.fromnumeric.reshape#1","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reshape","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-2,"name":"_AnyShapeT","namespace":"numpy._core.fromnumeric.reshape#1","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.reshape#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.reshape#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-2,"name":"_AnyShapeT","namespace":"numpy._core.fromnumeric.reshape#1","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,5],"arg_names":[null,"shape","order","copy"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.reshape","name":"reshape","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,5],"arg_names":[null,"shape","order","copy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["typing.SupportsIndex"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reshape","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.reshape#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.reshape","name":"reshape","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,5],"arg_names":[null,"shape","order","copy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["typing.SupportsIndex"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reshape","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.reshape#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,5],"arg_names":[null,"shape","order","copy"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.reshape","name":"reshape","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,5],"arg_names":[null,"shape","order","copy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reshape","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.reshape","name":"reshape","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,5],"arg_names":[null,"shape","order","copy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reshape","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,5],"arg_names":[null,"shape","order","copy"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.reshape","name":"reshape","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,5],"arg_names":[null,"shape","order","copy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.fromnumeric.reshape#4","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reshape","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.fromnumeric.reshape#4","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.fromnumeric.reshape#4","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.reshape","name":"reshape","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,5],"arg_names":[null,"shape","order","copy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.fromnumeric.reshape#4","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reshape","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.fromnumeric.reshape#4","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.fromnumeric.reshape#4","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,5],"arg_names":[null,"shape","order","copy"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.reshape","name":"reshape","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,5],"arg_names":[null,"shape","order","copy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["typing.SupportsIndex"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reshape","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.reshape","name":"reshape","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,5],"arg_names":[null,"shape","order","copy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["typing.SupportsIndex"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reshape","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,3,5],"arg_names":[null,"shape","order","newshape","copy"],"dataclass_transform_spec":null,"deprecated":"overload def (Any, shape: None =, order: Any =, *, newshape: Any, copy: builtins.bool | None =) -> Any of function numpy._core.fromnumeric.reshape is deprecated: `newshape` keyword argument is deprecated, use `shape=...` or pass shape positionally instead. (deprecated in NumPy 2.1)","flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.reshape","name":"reshape","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":[null,"shape","order","newshape","copy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reshape","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.reshape","name":"reshape","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":[null,"shape","order","newshape","copy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reshape","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,5],"arg_names":[null,"shape","order","copy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reshape","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.reshape#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.reshape#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,5],"arg_names":[null,"shape","order","copy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-2,"name":"_AnyShapeT","namespace":"numpy._core.fromnumeric.reshape#1","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reshape","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-2,"name":"_AnyShapeT","namespace":"numpy._core.fromnumeric.reshape#1","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.reshape#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.reshape#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-2,"name":"_AnyShapeT","namespace":"numpy._core.fromnumeric.reshape#1","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,5],"arg_names":[null,"shape","order","copy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["typing.SupportsIndex"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reshape","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.reshape#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,5],"arg_names":[null,"shape","order","copy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reshape","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,5],"arg_names":[null,"shape","order","copy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.fromnumeric.reshape#4","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reshape","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.fromnumeric.reshape#4","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.fromnumeric.reshape#4","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,5],"arg_names":[null,"shape","order","copy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["typing.SupportsIndex"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reshape","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":[null,"shape","order","newshape","copy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reshape","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"resize":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.resize","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","new_shape"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.resize","name":"resize","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","new_shape"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"TupleType","implicit":false,"items":["typing.SupportsIndex"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"resize","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.resize#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.resize#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.resize","name":"resize","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","new_shape"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"TupleType","implicit":false,"items":["typing.SupportsIndex"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"resize","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.resize#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.resize#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","new_shape"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.resize","name":"resize","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","new_shape"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-2,"name":"_AnyShapeT","namespace":"numpy._core.fromnumeric.resize#1","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"resize","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-2,"name":"_AnyShapeT","namespace":"numpy._core.fromnumeric.resize#1","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.resize#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.resize#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-2,"name":"_AnyShapeT","namespace":"numpy._core.fromnumeric.resize#1","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.resize","name":"resize","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","new_shape"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-2,"name":"_AnyShapeT","namespace":"numpy._core.fromnumeric.resize#1","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"resize","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-2,"name":"_AnyShapeT","namespace":"numpy._core.fromnumeric.resize#1","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.resize#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.resize#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-2,"name":"_AnyShapeT","namespace":"numpy._core.fromnumeric.resize#1","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","new_shape"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.resize","name":"resize","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","new_shape"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"resize","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.resize#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.resize","name":"resize","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","new_shape"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"resize","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.resize#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","new_shape"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.resize","name":"resize","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","new_shape"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"TupleType","implicit":false,"items":["typing.SupportsIndex"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"resize","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.resize","name":"resize","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","new_shape"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"TupleType","implicit":false,"items":["typing.SupportsIndex"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"resize","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","new_shape"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.resize","name":"resize","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","new_shape"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.fromnumeric.resize#4","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"resize","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.fromnumeric.resize#4","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.fromnumeric.resize#4","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.resize","name":"resize","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","new_shape"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.fromnumeric.resize#4","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"resize","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.fromnumeric.resize#4","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.fromnumeric.resize#4","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","new_shape"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.resize","name":"resize","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","new_shape"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"resize","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.resize","name":"resize","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","new_shape"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"resize","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","new_shape"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"TupleType","implicit":false,"items":["typing.SupportsIndex"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"resize","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.resize#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.resize#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","new_shape"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-2,"name":"_AnyShapeT","namespace":"numpy._core.fromnumeric.resize#1","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"resize","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-2,"name":"_AnyShapeT","namespace":"numpy._core.fromnumeric.resize#1","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.resize#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.resize#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-2,"name":"_AnyShapeT","namespace":"numpy._core.fromnumeric.resize#1","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","new_shape"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"resize","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.resize#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","new_shape"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"TupleType","implicit":false,"items":["typing.SupportsIndex"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"resize","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","new_shape"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.fromnumeric.resize#4","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"resize","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.fromnumeric.resize#4","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.fromnumeric.resize#4","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","new_shape"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"resize","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"round":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy._core.fromnumeric.round","name":"round","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","decimals","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","decimals","out"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._NumberOrObjectT","id":-1,"name":"_NumberOrObjectT","namespace":"numpy._core.fromnumeric.around#1","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0},"typing.SupportsIndex",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._NumberOrObjectT","id":-1,"name":"_NumberOrObjectT","namespace":"numpy._core.fromnumeric.around#1","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._NumberOrObjectT","id":-1,"name":"_NumberOrObjectT","namespace":"numpy._core.fromnumeric.around#1","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","decimals","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"numpy.object_"],"uses_pep604_syntax":true},"typing.SupportsIndex",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","decimals","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","decimals","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._NumberOrObjectT","id":-1,"name":"_NumberOrObjectT","namespace":"numpy._core.fromnumeric.around#4","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","decimals","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"typing.SupportsIndex",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["a","decimals","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"typing.SupportsIndex",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.around#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.around#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.around#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3],"arg_names":["a","decimals","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"typing.SupportsIndex",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.around","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.around","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.around","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"searchsorted":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.searchsorted","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","v","side","sorter"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.searchsorted","name":"searchsorted","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","v","side","sorter"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"searchsorted","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.searchsorted","name":"searchsorted","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","v","side","sorter"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"searchsorted","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","v","side","sorter"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.searchsorted","name":"searchsorted","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","v","side","sorter"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"searchsorted","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.searchsorted","name":"searchsorted","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","v","side","sorter"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"searchsorted","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","v","side","sorter"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"searchsorted","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","v","side","sorter"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"searchsorted","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"shape":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.shape","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.shape","name":"shape","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.Never","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy._core.fromnumeric._SupportsShape"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shape","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.shape","name":"shape","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.Never","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy._core.fromnumeric._SupportsShape"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shape","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.shape","name":"shape","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ShapeT","id":-1,"name":"_ShapeT","namespace":"numpy._core.fromnumeric.shape#1","upper_bound":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._core.fromnumeric._SupportsShape"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shape","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ShapeT","id":-1,"name":"_ShapeT","namespace":"numpy._core.fromnumeric.shape#1","upper_bound":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ShapeT","id":-1,"name":"_ShapeT","namespace":"numpy._core.fromnumeric.shape#1","upper_bound":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.shape","name":"shape","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ShapeT","id":-1,"name":"_ShapeT","namespace":"numpy._core.fromnumeric.shape#1","upper_bound":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._core.fromnumeric._SupportsShape"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shape","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ShapeT","id":-1,"name":"_ShapeT","namespace":"numpy._core.fromnumeric.shape#1","upper_bound":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ShapeT","id":-1,"name":"_ShapeT","namespace":"numpy._core.fromnumeric.shape#1","upper_bound":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.shape","name":"shape","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shape","ret_type":{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.shape","name":"shape","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shape","ret_type":{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.shape","name":"shape","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shape","ret_type":{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.shape","name":"shape","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shape","ret_type":{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.shape","name":"shape","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shape","ret_type":{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.shape","name":"shape","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shape","ret_type":{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.shape","name":"shape","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.memoryview"},"builtins.bytearray"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shape","ret_type":{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.shape","name":"shape","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.memoryview"},"builtins.bytearray"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shape","ret_type":{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.shape","name":"shape","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shape","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.shape","name":"shape","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shape","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.Never","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy._core.fromnumeric._SupportsShape"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shape","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ShapeT","id":-1,"name":"_ShapeT","namespace":"numpy._core.fromnumeric.shape#1","upper_bound":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._core.fromnumeric._SupportsShape"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shape","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ShapeT","id":-1,"name":"_ShapeT","namespace":"numpy._core.fromnumeric.shape#1","upper_bound":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ShapeT","id":-1,"name":"_ShapeT","namespace":"numpy._core.fromnumeric.shape#1","upper_bound":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shape","ret_type":{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shape","ret_type":{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.fromnumeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shape","ret_type":{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.memoryview"},"builtins.bytearray"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shape","ret_type":{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shape","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"size":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.size","name":"size","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"size","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"sort":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.sort","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","kind","order","stable"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.sort","name":"sort","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","kind","order","stable"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sort","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sort#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.sort","name":"sort","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","kind","order","stable"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sort","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sort#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","kind","order","stable"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.sort","name":"sort","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","kind","order","stable"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sort","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.sort","name":"sort","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","kind","order","stable"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sort","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","kind","order","stable"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sort","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sort#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","kind","order","stable"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sort","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"squeeze":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.squeeze","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.squeeze","name":"squeeze","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","axis"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.squeeze#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"squeeze","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.squeeze#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.squeeze#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.squeeze","name":"squeeze","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","axis"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.squeeze#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"squeeze","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.squeeze#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.squeeze#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.squeeze","name":"squeeze","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"squeeze","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.squeeze#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.squeeze","name":"squeeze","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"squeeze","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.squeeze#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.squeeze","name":"squeeze","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"squeeze","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.squeeze","name":"squeeze","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"squeeze","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","axis"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.squeeze#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"squeeze","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.squeeze#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.squeeze#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"squeeze","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.squeeze#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"squeeze","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"std":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.std","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.std","name":"std","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.float",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"std","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.std","name":"std","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.float",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"std","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.std","name":"std","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},"builtins.float","builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"std","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.std","name":"std","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},"builtins.float","builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"std","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.std","name":"std","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.float",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"std","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.std#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.std#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.std","name":"std","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.float",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"std","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.std#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.std#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3,5,5,5,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.std","name":"std","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,3,5,5,5,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.float",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"std","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.std#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.std#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.std","name":"std","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3,5,5,5,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.float",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"std","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.std#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.std#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.std","name":"std","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.float","builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"std","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.std","name":"std","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.float","builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"std","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.std","name":"std","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.std#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.float","builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"std","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.std#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.std#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.std","name":"std","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.std#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.float","builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"std","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.std#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.std#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,3,5,5,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.std","name":"std","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,3,5,5,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.std","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.float","builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"std","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.std","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.std","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.std","name":"std","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,3,5,5,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.std","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.float","builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"std","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.std","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.std","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.float",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"std","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},"builtins.float","builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"std","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.float",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"std","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.std#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.std#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5,5,5,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.float",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"std","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.std#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.std#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.float","builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"std","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.std#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.float","builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"std","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.std#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.std#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,3,5,5,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.std","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.float","builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"std","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.std","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.std","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"sum":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.sum","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.sum","name":"sum","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sum","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.sum","name":"sum","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sum","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.sum","name":"sum","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sum","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.sum","name":"sum","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sum","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.sum","name":"sum","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sum","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.sum","name":"sum","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sum","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3,5,5,5,5],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.sum","name":"sum","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,3,5,5,5,5],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sum","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.sum","name":"sum","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3,5,5,5,5],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sum","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.sum","name":"sum","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sum","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.sum","name":"sum","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sum","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3,5,5,5,5],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.sum","name":"sum","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,3,5,5,5,5],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sum","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.sum","name":"sum","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3,5,5,5,5],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sum","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.sum","name":"sum","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sum","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.sum","name":"sum","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sum","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.sum","name":"sum","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.sum#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sum","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.sum#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.sum#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.sum","name":"sum","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.sum#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sum","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.sum#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.sum#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,3,5,5,5],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.sum","name":"sum","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,3,5,5,5],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.sum","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sum","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.sum","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.sum","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.sum","name":"sum","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,3,5,5,5],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.sum","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sum","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.sum","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.sum","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sum","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sum","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sum","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5,5,5,5],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sum","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sum","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5,5,5,5],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sum","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sum","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.sum#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sum","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.sum#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.sum#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,3,5,5,5],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.sum","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sum","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.sum","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.sum","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"swapaxes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.swapaxes","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["a","axis1","axis2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.swapaxes","name":"swapaxes","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["a","axis1","axis2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"swapaxes","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.swapaxes#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.swapaxes","name":"swapaxes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["a","axis1","axis2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"swapaxes","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.swapaxes#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["a","axis1","axis2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.swapaxes","name":"swapaxes","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["a","axis1","axis2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"swapaxes","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.swapaxes","name":"swapaxes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["a","axis1","axis2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"swapaxes","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["a","axis1","axis2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"swapaxes","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.swapaxes#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["a","axis1","axis2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"swapaxes","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"take":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.take","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["a","indices","axis","out","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.take","name":"take","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.take#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.take#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.take","name":"take","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.take#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.take#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["a","indices","axis","out","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.take","name":"take","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.take","name":"take","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["a","indices","axis","out","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.take","name":"take","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.take#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.take","name":"take","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.take#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["a","indices","axis","out","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.take","name":"take","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.take","name":"take","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1],"arg_names":["a","indices","axis","out","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.take","name":"take","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["a","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.take#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.take#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.take#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.take","name":"take","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["a","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.take#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.take#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.take#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,3,5],"arg_names":["a","indices","axis","out","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.take","name":"take","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,3,5],"arg_names":["a","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.take","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.take","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.take","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.take","name":"take","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,3,5],"arg_names":["a","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.take","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.take","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.take","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.take#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.take#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.take#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["a","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.take#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.take#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.take#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,3,5],"arg_names":["a","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.take","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.take","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.take","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"timedelta64":{".class":"SymbolTableNode","cross_ref":"numpy.timedelta64","kind":"Gdef","module_hidden":true,"module_public":false},"trace":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.trace","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1],"arg_names":["a","offset","axis1","axis2","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.trace","name":"trace","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1],"arg_names":["a","offset","axis1","axis2","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","typing.SupportsIndex","typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trace","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.trace","name":"trace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1],"arg_names":["a","offset","axis1","axis2","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","typing.SupportsIndex","typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trace","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0,0],"arg_names":["a","offset","axis1","axis2","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.trace","name":"trace","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0],"arg_names":["a","offset","axis1","axis2","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","typing.SupportsIndex","typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.trace#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trace","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.trace#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.trace#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.trace","name":"trace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0],"arg_names":["a","offset","axis1","axis2","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","typing.SupportsIndex","typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.trace#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trace","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.trace#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.trace#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,3],"arg_names":["a","offset","axis1","axis2","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.trace","name":"trace","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,3],"arg_names":["a","offset","axis1","axis2","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","typing.SupportsIndex","typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.trace","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trace","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.trace","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.trace","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.trace","name":"trace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,3],"arg_names":["a","offset","axis1","axis2","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","typing.SupportsIndex","typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.trace","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trace","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.trace","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.trace","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1,1],"arg_names":["a","offset","axis1","axis2","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","typing.SupportsIndex","typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trace","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,0,0],"arg_names":["a","offset","axis1","axis2","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","typing.SupportsIndex","typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.trace#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trace","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.trace#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.trace#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,3],"arg_names":["a","offset","axis1","axis2","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","typing.SupportsIndex","typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.trace","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trace","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.trace","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.trace","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"transpose":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.transpose","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","axes"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.transpose","name":"transpose","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"transpose","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.transpose#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.transpose","name":"transpose","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"transpose","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.transpose#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","axes"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.transpose","name":"transpose","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"transpose","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.transpose","name":"transpose","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"transpose","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"transpose","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.transpose#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"transpose","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"type_check_only":{".class":"SymbolTableNode","cross_ref":"typing.type_check_only","kind":"Gdef","module_hidden":true,"module_public":false},"uint64":{".class":"SymbolTableNode","cross_ref":"numpy.uint64","kind":"Gdef","module_hidden":true,"module_public":false},"var":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.fromnumeric.var","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.var","name":"var","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.float",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"var","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.var","name":"var","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.float",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"var","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.var","name":"var","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},"builtins.float","builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"var","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.var","name":"var","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},"builtins.float","builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"var","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.var","name":"var","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.float",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"var","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.var#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.var#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.var","name":"var","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.float",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"var","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.var#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.var#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3,5,5,5,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.var","name":"var","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,3,5,5,5,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.float",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"var","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.var#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.var#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.var","name":"var","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3,5,5,5,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.float",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"var","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.var#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.var#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.var","name":"var","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.float","builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"var","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.var","name":"var","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.float","builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"var","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.var","name":"var","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.var#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.float","builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"var","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.var#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.var#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.var","name":"var","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.var#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.float","builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"var","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.var#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.var#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,3,5,5,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.fromnumeric.var","name":"var","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,3,5,5,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.var","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.float","builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"var","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.var","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.var","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.fromnumeric.var","name":"var","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,3,5,5,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.var","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.float","builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"var","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.var","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.var","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.float",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"var","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},"builtins.float","builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"var","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.float",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"var","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.var#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.var#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5,5,5,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.float",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"var","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.var#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.var#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.float","builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"var","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.var#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.float","builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"var","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.var#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.var#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,3,5,5,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.var","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.float","builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"var","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.var","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.var","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_core/fromnumeric.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/fromnumeric.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/fromnumeric.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..48c810de78f77e9d532df5c613f43201616e0cd2 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/fromnumeric.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[2,39,40,3,15,16,18,1,1,1,1,1,1],"dep_prios":[5,5,5,5,5,5,5,5,30,30,30,30,30],"dependencies":["collections.abc","numpy._globals","numpy._typing","typing","_typeshed","typing_extensions","numpy","builtins","_frozen_importlib","abc","datetime","numpy._typing._nbit_base","numpy._typing._nested_sequence"],"hash":"192d94956e6183a6742abd18e57e841af540488d","id":"numpy._core.fromnumeric","ignore_all":true,"interface_hash":"365d4c50bb74b62d4292a033800aacf38fbf50bb","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_core/fromnumeric.pyi","plugin_data":null,"size":42034,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/function_base.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/function_base.data.json new file mode 100644 index 0000000000000000000000000000000000000000..00f418cd6cf5a2d2603ca1bdf88126aacd260417 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/function_base.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy._core.function_base","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","DTypeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like.DTypeLike","kind":"Gdef","module_hidden":true,"module_public":false},"Incomplete":{".class":"SymbolTableNode","cross_ref":"_typeshed.Incomplete","kind":"Gdef","module_hidden":true,"module_public":false},"L":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"SupportsIndex":{".class":"SymbolTableNode","cross_ref":"typing.SupportsIndex","kind":"Gdef","module_hidden":true,"module_public":false},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy._core.function_base.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.function_base.TypeAlias","source_any":null,"type_of_any":3}}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeComplex_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeComplex_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeFloat_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeFloat_co","kind":"Gdef","module_hidden":true,"module_public":false},"_DTypeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._DTypeLike","kind":"Gdef","module_hidden":true,"module_public":false},"_DualArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._DualArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"_ScalarT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.function_base._ScalarT","name":"_ScalarT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},"_ToArrayFloat64":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._core.function_base._ToArrayFloat64","name":"_ToArrayFloat64","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.function_base.TypeAlias","source_any":null,"type_of_any":3}}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy._core.function_base.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.function_base.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.function_base.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.function_base.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.function_base.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.function_base.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.function_base.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"add_newdoc":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["place","obj","doc","warn_on_python"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.function_base.add_newdoc","name":"add_newdoc","original_first_arg":"place","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["place","obj","doc","warn_on_python"],"arg_types":["builtins.str","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"builtins.list"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add_newdoc","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"geomspace":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.function_base.geomspace","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1],"arg_names":["start","stop","num","endpoint","dtype","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.function_base.geomspace","name":"geomspace","original_first_arg":"start","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["start","stop","num","endpoint","dtype","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.function_base.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.function_base.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"NoneType"},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"geomspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.function_base.geomspace","name":"geomspace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["start","stop","num","endpoint","dtype","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.function_base.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.function_base.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"NoneType"},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"geomspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1],"arg_names":["start","stop","num","endpoint","dtype","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.function_base.geomspace","name":"geomspace","original_first_arg":"start","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["start","stop","num","endpoint","dtype","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"NoneType"},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"geomspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.function_base.geomspace","name":"geomspace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["start","stop","num","endpoint","dtype","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"NoneType"},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"geomspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1],"arg_names":["start","stop","num","endpoint","dtype","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.function_base.geomspace","name":"geomspace","original_first_arg":"start","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["start","stop","num","endpoint","dtype","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"NoneType"},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"geomspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.function_base.geomspace","name":"geomspace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["start","stop","num","endpoint","dtype","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"NoneType"},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"geomspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0,1],"arg_names":["start","stop","num","endpoint","dtype","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.function_base.geomspace","name":"geomspace","original_first_arg":"start","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,1],"arg_names":["start","stop","num","endpoint","dtype","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"geomspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.function_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.function_base.geomspace#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.function_base.geomspace","name":"geomspace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,1],"arg_names":["start","stop","num","endpoint","dtype","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"geomspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.function_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.function_base.geomspace#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,3,5],"arg_names":["start","stop","num","endpoint","dtype","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.function_base.geomspace","name":"geomspace","original_first_arg":"start","type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["start","stop","num","endpoint","dtype","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"geomspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.function_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.function_base.geomspace#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.function_base.geomspace","name":"geomspace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["start","stop","num","endpoint","dtype","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"geomspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.function_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.function_base.geomspace#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1],"arg_names":["start","stop","num","endpoint","dtype","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.function_base.geomspace","name":"geomspace","original_first_arg":"start","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["start","stop","num","endpoint","dtype","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"geomspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.function_base.geomspace","name":"geomspace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["start","stop","num","endpoint","dtype","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"geomspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["start","stop","num","endpoint","dtype","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.function_base.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.function_base.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"NoneType"},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"geomspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["start","stop","num","endpoint","dtype","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"NoneType"},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"geomspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["start","stop","num","endpoint","dtype","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"NoneType"},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"geomspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,0,1],"arg_names":["start","stop","num","endpoint","dtype","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"geomspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.function_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.function_base.geomspace#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["start","stop","num","endpoint","dtype","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"geomspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.function_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.function_base.geomspace#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["start","stop","num","endpoint","dtype","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"geomspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"linspace":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.function_base.linspace","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.function_base.linspace","name":"linspace","original_first_arg":"start","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.function_base.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.function_base.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"linspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.function_base.linspace","name":"linspace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.function_base.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.function_base.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"linspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.function_base.linspace","name":"linspace","original_first_arg":"start","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"linspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.function_base.linspace","name":"linspace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"linspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.function_base.linspace","name":"linspace","original_first_arg":"start","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"linspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.function_base.linspace","name":"linspace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"linspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0,0,1,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.function_base.linspace","name":"linspace","original_first_arg":"start","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,1,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"linspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.function_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.function_base.linspace#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.function_base.linspace","name":"linspace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,1,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"linspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.function_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.function_base.linspace#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,3,5,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.function_base.linspace","name":"linspace","original_first_arg":"start","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,3,5,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"linspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.function_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.function_base.linspace#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.function_base.linspace","name":"linspace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,3,5,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"linspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.function_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.function_base.linspace#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.function_base.linspace","name":"linspace","original_first_arg":"start","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"linspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.function_base.linspace","name":"linspace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"linspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,3,5,5,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.function_base.linspace","name":"linspace","original_first_arg":"start","type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5,5,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.function_base.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.function_base.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"NoneType"},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"linspace","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy.float64"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.function_base.linspace","name":"linspace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5,5,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.function_base.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.function_base.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"NoneType"},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"linspace","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy.float64"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,3,5,5,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.function_base.linspace","name":"linspace","original_first_arg":"start","type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5,5,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"NoneType"},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"linspace","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.function_base.linspace","name":"linspace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5,5,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"NoneType"},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"linspace","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,3,5,5,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.function_base.linspace","name":"linspace","original_first_arg":"start","type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5,5,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"NoneType"},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"linspace","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.function_base.linspace","name":"linspace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5,5,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"NoneType"},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"linspace","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,3,3,5,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.function_base.linspace","name":"linspace","original_first_arg":"start","type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,3,5,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"linspace","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.function_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.function_base.linspace#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.function_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.function_base.linspace#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.function_base.linspace","name":"linspace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,3,5,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"linspace","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.function_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.function_base.linspace#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.function_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.function_base.linspace#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,3,5,5,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.function_base.linspace","name":"linspace","original_first_arg":"start","type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5,5,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"linspace","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.function_base.linspace","name":"linspace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5,5,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"linspace","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.function_base.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.function_base.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"linspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"linspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"linspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,1,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"linspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.function_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.function_base.linspace#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,3,5,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"linspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.function_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.function_base.linspace#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"linspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,3,5,5,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.function_base.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.function_base.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"NoneType"},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"linspace","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy.float64"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,3,5,5,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"NoneType"},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"linspace","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,3,5,5,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"NoneType"},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"linspace","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,3,3,5,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"linspace","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.function_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.function_base.linspace#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.function_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.function_base.linspace#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,3,5,5,5],"arg_names":["start","stop","num","endpoint","retstep","dtype","axis","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"linspace","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"logspace":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.function_base.logspace","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1],"arg_names":["start","stop","num","endpoint","base","dtype","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.function_base.logspace","name":"logspace","original_first_arg":"start","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":["start","stop","num","endpoint","base","dtype","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.function_base.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.function_base.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"AnyType","missing_import_name":"numpy._core.function_base.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.function_base.logspace","name":"logspace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":["start","stop","num","endpoint","base","dtype","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.function_base.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.function_base.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"AnyType","missing_import_name":"numpy._core.function_base.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1],"arg_names":["start","stop","num","endpoint","base","dtype","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.function_base.logspace","name":"logspace","original_first_arg":"start","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":["start","stop","num","endpoint","base","dtype","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.function_base.logspace","name":"logspace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":["start","stop","num","endpoint","base","dtype","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1],"arg_names":["start","stop","num","endpoint","base","dtype","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.function_base.logspace","name":"logspace","original_first_arg":"start","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":["start","stop","num","endpoint","base","dtype","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.function_base.logspace","name":"logspace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":["start","stop","num","endpoint","base","dtype","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0,0,1],"arg_names":["start","stop","num","endpoint","base","dtype","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.function_base.logspace","name":"logspace","original_first_arg":"start","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,1],"arg_names":["start","stop","num","endpoint","base","dtype","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.function_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.function_base.logspace#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.function_base.logspace","name":"logspace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,1],"arg_names":["start","stop","num","endpoint","base","dtype","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.function_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.function_base.logspace#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,3,5],"arg_names":["start","stop","num","endpoint","base","dtype","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.function_base.logspace","name":"logspace","original_first_arg":"start","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,3,5],"arg_names":["start","stop","num","endpoint","base","dtype","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.function_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.function_base.logspace#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.function_base.logspace","name":"logspace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,3,5],"arg_names":["start","stop","num","endpoint","base","dtype","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.function_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.function_base.logspace#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1],"arg_names":["start","stop","num","endpoint","base","dtype","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.function_base.logspace","name":"logspace","original_first_arg":"start","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":["start","stop","num","endpoint","base","dtype","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.function_base.logspace","name":"logspace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":["start","stop","num","endpoint","base","dtype","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":["start","stop","num","endpoint","base","dtype","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.function_base.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.function_base.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"AnyType","missing_import_name":"numpy._core.function_base.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":["start","stop","num","endpoint","base","dtype","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":["start","stop","num","endpoint","base","dtype","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,1],"arg_names":["start","stop","num","endpoint","base","dtype","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.function_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.function_base.logspace#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,3,5],"arg_names":["start","stop","num","endpoint","base","dtype","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.function_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.function_base.logspace#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":["start","stop","num","endpoint","base","dtype","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_core/function_base.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/function_base.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/function_base.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..95384d5cdf575b9d1f105c189202ea7bbc54b09e --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/function_base.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[14,7,1,4,6,1,1,1,1,1,1,1,1,1],"dep_prios":[5,5,5,5,10,5,30,30,30,30,30,30,30,30],"dependencies":["numpy._typing._array_like","numpy._typing","typing","_typeshed","numpy","builtins","_ctypes","_frozen_importlib","abc","ctypes","datetime","numpy._typing._nbit_base","numpy.dtypes","typing_extensions"],"hash":"59bb1daa900b8290b8c716c8341f379ee74c0639","id":"numpy._core.function_base","ignore_all":true,"interface_hash":"c0a1145e6a48841967dac5d07cac521787b886cf","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_core/function_base.pyi","plugin_data":null,"size":7064,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/multiarray.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/multiarray.data.json new file mode 100644 index 0000000000000000000000000000000000000000..4991eb7036aec42f3e306917e0b3734c80285d4c --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/multiarray.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy._core.multiarray","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","ALLOW_THREADS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy._core.multiarray.ALLOW_THREADS","name":"ALLOW_THREADS","setter_type":null,"type":"builtins.int"}},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"BUFSIZE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.multiarray.BUFSIZE","name":"BUFSIZE","setter_type":null,"type":{".class":"LiteralType","fallback":"builtins.int","value":8192}}},"CLIP":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.multiarray.CLIP","name":"CLIP","setter_type":null,"type":{".class":"LiteralType","fallback":"builtins.int","value":0}}},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef","module_hidden":true,"module_public":false},"CapsuleType":{".class":"SymbolTableNode","cross_ref":"typing_extensions.CapsuleType","kind":"Gdef","module_hidden":true,"module_public":false},"ClassVar":{".class":"SymbolTableNode","cross_ref":"typing.ClassVar","kind":"Gdef","module_hidden":true,"module_public":false},"DATETIMEUNITS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy._core.multiarray.DATETIMEUNITS","name":"DATETIMEUNITS","setter_type":null,"type":"typing_extensions.CapsuleType"}},"DTypeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like.DTypeLike","kind":"Gdef","module_hidden":true,"module_public":false},"Final":{".class":"SymbolTableNode","cross_ref":"typing.Final","kind":"Gdef","module_hidden":true,"module_public":false},"ITEM_HASOBJECT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","final_value":1,"flags":["is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"numpy._core.multiarray.ITEM_HASOBJECT","name":"ITEM_HASOBJECT","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.int","value":1},"type_ref":"builtins.int"}}},"ITEM_IS_POINTER":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","final_value":4,"flags":["is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"numpy._core.multiarray.ITEM_IS_POINTER","name":"ITEM_IS_POINTER","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.int","value":4},"type_ref":"builtins.int"}}},"Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef","module_hidden":true,"module_public":false},"L":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"LIST_PICKLE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","final_value":2,"flags":["is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"numpy._core.multiarray.LIST_PICKLE","name":"LIST_PICKLE","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.int","value":2},"type_ref":"builtins.int"}}},"MAXDIMS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.multiarray.MAXDIMS","name":"MAXDIMS","setter_type":null,"type":{".class":"LiteralType","fallback":"builtins.int","value":32}}},"MAY_SHARE_BOUNDS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.multiarray.MAY_SHARE_BOUNDS","name":"MAY_SHARE_BOUNDS","setter_type":null,"type":{".class":"LiteralType","fallback":"builtins.int","value":0}}},"MAY_SHARE_EXACT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.multiarray.MAY_SHARE_EXACT","name":"MAY_SHARE_EXACT","setter_type":null,"type":{".class":"LiteralType","fallback":"builtins.int","value":-1}}},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"NEEDS_INIT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","final_value":8,"flags":["is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"numpy._core.multiarray.NEEDS_INIT","name":"NEEDS_INIT","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.int","value":8},"type_ref":"builtins.int"}}},"NEEDS_PYAPI":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","final_value":16,"flags":["is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"numpy._core.multiarray.NEEDS_PYAPI","name":"NEEDS_PYAPI","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.int","value":16},"type_ref":"builtins.int"}}},"Protocol":{".class":"SymbolTableNode","cross_ref":"typing.Protocol","kind":"Gdef","module_hidden":true,"module_public":false},"RAISE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.multiarray.RAISE","name":"RAISE","setter_type":null,"type":{".class":"LiteralType","fallback":"builtins.int","value":2}}},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef","module_hidden":true,"module_public":false},"StrOrBytesPath":{".class":"SymbolTableNode","cross_ref":"_typeshed.StrOrBytesPath","kind":"Gdef","module_hidden":true,"module_public":false},"SupportsIndex":{".class":"SymbolTableNode","cross_ref":"typing.SupportsIndex","kind":"Gdef","module_hidden":true,"module_public":false},"SupportsLenAndGetItem":{".class":"SymbolTableNode","cross_ref":"_typeshed.SupportsLenAndGetItem","kind":"Gdef","module_hidden":true,"module_public":false},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy._core.multiarray.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3}}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"TypedDict":{".class":"SymbolTableNode","cross_ref":"typing.TypedDict","kind":"Gdef","module_hidden":true,"module_public":false},"USE_GETITEM":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","final_value":32,"flags":["is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"numpy._core.multiarray.USE_GETITEM","name":"USE_GETITEM","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.int","value":32},"type_ref":"builtins.int"}}},"USE_SETITEM":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","final_value":64,"flags":["is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"numpy._core.multiarray.USE_SETITEM","name":"USE_SETITEM","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.int","value":64},"type_ref":"builtins.int"}}},"Unpack":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy._core.multiarray.Unpack","name":"Unpack","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}}},"WRAP":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.multiarray.WRAP","name":"WRAP","setter_type":null,"type":{".class":"LiteralType","fallback":"builtins.int","value":1}}},"_2PTuple":{".class":"SymbolTableNode","cross_ref":"numpy._typing._ufunc._2PTuple","kind":"Gdef","module_hidden":true,"module_public":false},"_ARRAY_API":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy._core.multiarray._ARRAY_API","name":"_ARRAY_API","setter_type":null,"type":"typing_extensions.CapsuleType"}},"_AnyShapeT":{".class":"SymbolTableNode","cross_ref":"numpy._AnyShapeT","kind":"Gdef","module_hidden":true,"module_public":false},"_Array":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._core.multiarray._Array","name":"_Array","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3}}},"_Array1D":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._core.multiarray._Array1D","name":"_Array1D","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3}}},"_ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeBool_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeBool_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeBytes_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeBytes_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeComplex_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeComplex_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeDT64_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeDT64_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeFloat_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeFloat_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeInt_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeInt_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeObject_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeObject_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeStr_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeStr_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeTD64_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeTD64_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeUInt_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeUInt_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","name":"_ArrayT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}},"_ArrayT_co":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT_co","name":"_ArrayT_co","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":1}},"_CastingKind":{".class":"SymbolTableNode","cross_ref":"numpy._CastingKind","kind":"Gdef","module_hidden":true,"module_public":false},"_ConstructorEmpty":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._core.multiarray._ConstructorEmpty","name":"_ConstructorEmpty","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy._core.multiarray._ConstructorEmpty","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy._core.multiarray","mro":["numpy._core.multiarray._ConstructorEmpty","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.multiarray._ConstructorEmpty.__call__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._core.multiarray._ConstructorEmpty.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"arg_types":["numpy._core.multiarray._ConstructorEmpty","typing.SupportsIndex",{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ConstructorEmpty","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray._ConstructorEmpty.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"arg_types":["numpy._core.multiarray._ConstructorEmpty","typing.SupportsIndex",{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ConstructorEmpty","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._core.multiarray._ConstructorEmpty.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"arg_types":["numpy._core.multiarray._ConstructorEmpty","typing.SupportsIndex",{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ConstructorEmpty","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray._ConstructorEmpty.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"arg_types":["numpy._core.multiarray._ConstructorEmpty","typing.SupportsIndex",{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ConstructorEmpty","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._core.multiarray._ConstructorEmpty.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"arg_types":["numpy._core.multiarray._ConstructorEmpty","typing.SupportsIndex",{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ConstructorEmpty","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray._ConstructorEmpty.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"arg_types":["numpy._core.multiarray._ConstructorEmpty","typing.SupportsIndex",{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ConstructorEmpty","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._core.multiarray._ConstructorEmpty.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"arg_types":["numpy._core.multiarray._ConstructorEmpty","typing.SupportsIndex",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ConstructorEmpty","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray._ConstructorEmpty.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"arg_types":["numpy._core.multiarray._ConstructorEmpty","typing.SupportsIndex",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ConstructorEmpty","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._core.multiarray._ConstructorEmpty.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"arg_types":["numpy._core.multiarray._ConstructorEmpty",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#4","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ConstructorEmpty","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#4","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray._ConstructorEmpty.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"arg_types":["numpy._core.multiarray._ConstructorEmpty",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#4","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ConstructorEmpty","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#4","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._core.multiarray._ConstructorEmpty.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"arg_types":["numpy._core.multiarray._ConstructorEmpty",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#5","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-2,"name":"_DTypeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-2,"name":"_DTypeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ConstructorEmpty","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#5","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-2,"name":"_DTypeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#5","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-2,"name":"_DTypeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray._ConstructorEmpty.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"arg_types":["numpy._core.multiarray._ConstructorEmpty",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#5","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-2,"name":"_DTypeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-2,"name":"_DTypeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ConstructorEmpty","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#5","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-2,"name":"_DTypeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#5","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-2,"name":"_DTypeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._core.multiarray._ConstructorEmpty.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"arg_types":["numpy._core.multiarray._ConstructorEmpty",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#6","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-2,"name":"_ScalarT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ConstructorEmpty","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#6","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-2,"name":"_ScalarT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray._ConstructorEmpty.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"arg_types":["numpy._core.multiarray._ConstructorEmpty",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#6","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-2,"name":"_ScalarT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ConstructorEmpty","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#6","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-2,"name":"_ScalarT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._core.multiarray._ConstructorEmpty.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"arg_types":["numpy._core.multiarray._ConstructorEmpty",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#7","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ConstructorEmpty","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#7","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray._ConstructorEmpty.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"arg_types":["numpy._core.multiarray._ConstructorEmpty",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#7","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ConstructorEmpty","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#7","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._core.multiarray._ConstructorEmpty.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"arg_types":["numpy._core.multiarray._ConstructorEmpty",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ConstructorEmpty","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray._ConstructorEmpty.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"arg_types":["numpy._core.multiarray._ConstructorEmpty",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ConstructorEmpty","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._core.multiarray._ConstructorEmpty.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"arg_types":["numpy._core.multiarray._ConstructorEmpty",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ConstructorEmpty","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray._ConstructorEmpty.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"arg_types":["numpy._core.multiarray._ConstructorEmpty",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ConstructorEmpty","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._core.multiarray._ConstructorEmpty.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"arg_types":["numpy._core.multiarray._ConstructorEmpty",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#10","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ConstructorEmpty","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#10","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray._ConstructorEmpty.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"arg_types":["numpy._core.multiarray._ConstructorEmpty",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#10","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ConstructorEmpty","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#10","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._core.multiarray._ConstructorEmpty.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"arg_types":["numpy._core.multiarray._ConstructorEmpty",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ConstructorEmpty","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray._ConstructorEmpty.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"arg_types":["numpy._core.multiarray._ConstructorEmpty",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ConstructorEmpty","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"arg_types":["numpy._core.multiarray._ConstructorEmpty","typing.SupportsIndex",{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ConstructorEmpty","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"arg_types":["numpy._core.multiarray._ConstructorEmpty","typing.SupportsIndex",{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ConstructorEmpty","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"arg_types":["numpy._core.multiarray._ConstructorEmpty","typing.SupportsIndex",{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ConstructorEmpty","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"arg_types":["numpy._core.multiarray._ConstructorEmpty","typing.SupportsIndex",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ConstructorEmpty","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"arg_types":["numpy._core.multiarray._ConstructorEmpty",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#4","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ConstructorEmpty","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#4","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"arg_types":["numpy._core.multiarray._ConstructorEmpty",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#5","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-2,"name":"_DTypeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-2,"name":"_DTypeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ConstructorEmpty","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#5","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-2,"name":"_DTypeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#5","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-2,"name":"_DTypeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"arg_types":["numpy._core.multiarray._ConstructorEmpty",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#6","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-2,"name":"_ScalarT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ConstructorEmpty","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#6","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-2,"name":"_ScalarT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"arg_types":["numpy._core.multiarray._ConstructorEmpty",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#7","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ConstructorEmpty","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#7","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"arg_types":["numpy._core.multiarray._ConstructorEmpty",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ConstructorEmpty","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"arg_types":["numpy._core.multiarray._ConstructorEmpty",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ConstructorEmpty","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"arg_types":["numpy._core.multiarray._ConstructorEmpty",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#10","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ConstructorEmpty","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray._ConstructorEmpty.__call__#10","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,4],"arg_names":[null,"shape","dtype","order","kwargs"],"arg_types":["numpy._core.multiarray._ConstructorEmpty",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ConstructorEmpty","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ConstructorEmpty.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy._core.multiarray._ConstructorEmpty","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_CopyMode":{".class":"SymbolTableNode","cross_ref":"numpy._globals._CopyMode","kind":"Gdef","module_hidden":true,"module_public":false},"_DTypeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._DTypeLike","kind":"Gdef","module_hidden":true,"module_public":false},"_DTypeT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","name":"_DTypeT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}},"_FloatLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._FloatLike_co","kind":"Gdef","module_hidden":true,"module_public":false},"_GetItemKeys":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._core.multiarray._GetItemKeys","name":"_GetItemKeys","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3}}},"_IDType":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","name":"_IDType","upper_bound":"builtins.object","values":[],"variance":0}},"_IntLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._IntLike_co","kind":"Gdef","module_hidden":true,"module_public":false},"_KwargsEmpty":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._core.multiarray._KwargsEmpty","name":"_KwargsEmpty","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy._core.multiarray._KwargsEmpty","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._core.multiarray","mro":["numpy._core.multiarray._KwargsEmpty","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["device",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],["like",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}]],"readonly_keys":[],"required_keys":[]}}},"_ModeKind":{".class":"SymbolTableNode","cross_ref":"numpy._ModeKind","kind":"Gdef","module_hidden":true,"module_public":false},"_NDIterFlagsKind":{".class":"SymbolTableNode","cross_ref":"numpy._NDIterFlagsKind","kind":"Gdef","module_hidden":true,"module_public":false},"_NDIterFlagsOp":{".class":"SymbolTableNode","cross_ref":"numpy._NDIterFlagsOp","kind":"Gdef","module_hidden":true,"module_public":false},"_NestedSequence":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nested_sequence._NestedSequence","kind":"Gdef","module_hidden":true,"module_public":false},"_Nin":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","name":"_Nin","upper_bound":"builtins.int","values":[],"variance":0}},"_Nout":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nout","name":"_Nout","upper_bound":"builtins.int","values":[],"variance":0}},"_OrderCF":{".class":"SymbolTableNode","cross_ref":"numpy._OrderCF","kind":"Gdef","module_hidden":true,"module_public":false},"_OrderKACF":{".class":"SymbolTableNode","cross_ref":"numpy._OrderKACF","kind":"Gdef","module_hidden":true,"module_public":false},"_PyFunc_Nin1P_Nout2P":{".class":"SymbolTableNode","cross_ref":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","kind":"Gdef","module_hidden":true,"module_public":false},"_PyFunc_Nin1_Nout1":{".class":"SymbolTableNode","cross_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","kind":"Gdef","module_hidden":true,"module_public":false},"_PyFunc_Nin2_Nout1":{".class":"SymbolTableNode","cross_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","kind":"Gdef","module_hidden":true,"module_public":false},"_PyFunc_Nin3P_Nout1":{".class":"SymbolTableNode","cross_ref":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","kind":"Gdef","module_hidden":true,"module_public":false},"_ReturnType":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","name":"_ReturnType","upper_bound":"builtins.object","values":[],"variance":0}},"_RollKind":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._core.multiarray._RollKind","name":"_RollKind","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3}}},"_ScalarLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._ScalarLike_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ScalarT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","name":"_ScalarT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},"_SetItemKeys":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._core.multiarray._SetItemKeys","name":"_SetItemKeys","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3}}},"_Shape":{".class":"SymbolTableNode","cross_ref":"numpy._typing._shape._Shape","kind":"Gdef","module_hidden":true,"module_public":false},"_ShapeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._shape._ShapeLike","kind":"Gdef","module_hidden":true,"module_public":false},"_ShapeT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ShapeT","name":"_ShapeT","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}},"_SupportsArray":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._core.multiarray._SupportsArray","name":"_SupportsArray","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT_co","id":1,"name":"_ArrayT_co","namespace":"numpy._core.multiarray._SupportsArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy._core.multiarray._SupportsArray","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy._core.multiarray","mro":["numpy._core.multiarray._SupportsArray","builtins.object"],"names":{".class":"SymbolTable","__array__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core.multiarray._SupportsArray.__array__","name":"__array__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT_co","id":1,"name":"_ArrayT_co","namespace":"numpy._core.multiarray._SupportsArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.multiarray._SupportsArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__array__ of _SupportsArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT_co","id":1,"name":"_ArrayT_co","namespace":"numpy._core.multiarray._SupportsArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._SupportsArray.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT_co","id":1,"name":"_ArrayT_co","namespace":"numpy._core.multiarray._SupportsArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.multiarray._SupportsArray"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_ArrayT_co"],"typeddict_type":null}},"_SupportsArrayFunc":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._SupportsArrayFunc","kind":"Gdef","module_hidden":true,"module_public":false},"_SupportsBuffer":{".class":"SymbolTableNode","cross_ref":"numpy._SupportsBuffer","kind":"Gdef","module_hidden":true,"module_public":false},"_SupportsDType":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._SupportsDType","kind":"Gdef","module_hidden":true,"module_public":false},"_SupportsFileMethods":{".class":"SymbolTableNode","cross_ref":"numpy._SupportsFileMethods","kind":"Gdef","module_hidden":true,"module_public":false},"_TD64Like_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._TD64Like_co","kind":"Gdef","module_hidden":true,"module_public":false},"_UnitKind":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._core.multiarray._UnitKind","name":"_UnitKind","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3}}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy._core.multiarray.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.multiarray.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.multiarray.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.multiarray.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.multiarray.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.multiarray.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.multiarray.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_flagdict":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy._core.multiarray._flagdict","name":"_flagdict","setter_type":null,"type":{".class":"Instance","args":["builtins.str","builtins.int"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_monotonicity":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy._core.multiarray._monotonicity","name":"_monotonicity","setter_type":null,"type":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":"builtins.object","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_place":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy._core.multiarray._place","name":"_place","setter_type":null,"type":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":"builtins.object","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_reconstruct":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy._core.multiarray._reconstruct","name":"_reconstruct","setter_type":null,"type":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":"builtins.object","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_vec_string":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy._core.multiarray._vec_string","name":"_vec_string","setter_type":null,"type":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":"builtins.object","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"add_docstring":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.add_docstring","name":"add_docstring","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add_docstring","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"arange":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.arange","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5],"arg_names":[null,"dtype","device","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.arange","name":"arange","original_first_arg":"stop","type":{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":[null,"dtype","device","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arange","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.arange","name":"arange","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":[null,"dtype","device","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arange","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,5,5],"arg_names":["start","stop","step","dtype","device","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.arange","name":"arange","original_first_arg":"start","type":{".class":"CallableType","arg_kinds":[0,0,1,1,5,5],"arg_names":["start","stop","step","dtype","device","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arange","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.arange","name":"arange","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,5,5],"arg_names":["start","stop","step","dtype","device","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arange","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5],"arg_names":[null,"dtype","device","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.arange","name":"arange","original_first_arg":"stop","type":{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":[null,"dtype","device","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arange","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.arange","name":"arange","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":[null,"dtype","device","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arange","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,5,5],"arg_names":["start","stop","step","dtype","device","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.arange","name":"arange","original_first_arg":"start","type":{".class":"CallableType","arg_kinds":[0,0,1,1,5,5],"arg_names":["start","stop","step","dtype","device","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arange","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.arange","name":"arange","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,5,5],"arg_names":["start","stop","step","dtype","device","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arange","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5],"arg_names":[null,"dtype","device","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.arange","name":"arange","original_first_arg":"stop","type":{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":[null,"dtype","device","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arange","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.arange","name":"arange","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":[null,"dtype","device","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arange","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,5,5],"arg_names":["start","stop","step","dtype","device","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.arange","name":"arange","original_first_arg":"start","type":{".class":"CallableType","arg_kinds":[0,0,1,1,5,5],"arg_names":["start","stop","step","dtype","device","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arange","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.arange","name":"arange","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,5,5],"arg_names":["start","stop","step","dtype","device","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arange","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,5,5],"arg_names":["start","stop","step","dtype","device","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.arange","name":"arange","original_first_arg":"start","type":{".class":"CallableType","arg_kinds":[0,0,1,1,5,5],"arg_names":["start","stop","step","dtype","device","like"],"arg_types":[{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arange","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.arange","name":"arange","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,5,5],"arg_names":["start","stop","step","dtype","device","like"],"arg_types":[{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arange","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,5,5],"arg_names":[null,"dtype","device","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.arange","name":"arange","original_first_arg":"stop","type":{".class":"CallableType","arg_kinds":[0,3,5,5],"arg_names":[null,"dtype","device","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arange","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.arange#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.arange","name":"arange","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,3,5,5],"arg_names":[null,"dtype","device","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arange","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.arange#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,5,5],"arg_names":["start","stop","step","dtype","device","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.arange","name":"arange","original_first_arg":"start","type":{".class":"CallableType","arg_kinds":[0,0,1,1,5,5],"arg_names":["start","stop","step","dtype","device","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arange","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.arange#8","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.arange","name":"arange","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,5,5],"arg_names":["start","stop","step","dtype","device","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arange","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.arange#8","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5],"arg_names":[null,"dtype","device","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.arange","name":"arange","original_first_arg":"stop","type":{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":[null,"dtype","device","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arange","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.arange","name":"arange","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":[null,"dtype","device","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arange","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,5,5],"arg_names":["start","stop","step","dtype","device","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.arange","name":"arange","original_first_arg":"start","type":{".class":"CallableType","arg_kinds":[0,0,1,1,5,5],"arg_names":["start","stop","step","dtype","device","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arange","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.arange","name":"arange","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,5,5],"arg_names":["start","stop","step","dtype","device","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arange","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":[null,"dtype","device","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arange","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,5,5],"arg_names":["start","stop","step","dtype","device","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arange","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":[null,"dtype","device","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arange","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,5,5],"arg_names":["start","stop","step","dtype","device","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arange","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":[null,"dtype","device","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arange","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,5,5],"arg_names":["start","stop","step","dtype","device","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arange","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,5,5],"arg_names":["start","stop","step","dtype","device","like"],"arg_types":[{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arange","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,3,5,5],"arg_names":[null,"dtype","device","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arange","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.arange#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,5,5],"arg_names":["start","stop","step","dtype","device","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arange","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.arange#8","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":[null,"dtype","device","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arange","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,5,5],"arg_names":["start","stop","step","dtype","device","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arange","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"array":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.array","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,5,5,3,5,5],"arg_names":["object","dtype","copy","order","subok","ndmin","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.array","name":"array","original_first_arg":"object","type":{".class":"CallableType","arg_kinds":[0,1,5,5,3,5,5],"arg_names":["object","dtype","copy","order","subok","ndmin","like"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.array#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._CopyMode",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},"builtins.int",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.array#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.array#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.array","name":"array","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,5,5,3,5,5],"arg_names":["object","dtype","copy","order","subok","ndmin","like"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.array#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._CopyMode",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},"builtins.int",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.array#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.array#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,5,5,3,5,5],"arg_names":["object","dtype","copy","order","subok","ndmin","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.array","name":"array","original_first_arg":"object","type":{".class":"CallableType","arg_kinds":[0,1,5,5,3,5,5],"arg_names":["object","dtype","copy","order","subok","ndmin","like"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.array#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._core.multiarray._SupportsArray"},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._CopyMode",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.int","value":0},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.array#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.array#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.array","name":"array","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,5,5,3,5,5],"arg_names":["object","dtype","copy","order","subok","ndmin","like"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.array#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._core.multiarray._SupportsArray"},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._CopyMode",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.int","value":0},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.array#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.array#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,5,5,5,5,5],"arg_names":["object","dtype","copy","order","subok","ndmin","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.array","name":"array","original_first_arg":"object","type":{".class":"CallableType","arg_kinds":[0,1,5,5,5,5,5],"arg_names":["object","dtype","copy","order","subok","ndmin","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._CopyMode",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.int",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.array#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.array","name":"array","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,5,5,5,5,5],"arg_names":["object","dtype","copy","order","subok","ndmin","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._CopyMode",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.int",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.array#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5],"arg_names":["object","dtype","copy","order","subok","ndmin","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.array","name":"array","original_first_arg":"object","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5],"arg_names":["object","dtype","copy","order","subok","ndmin","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.bool","numpy._globals._CopyMode",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.int",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.array#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.array","name":"array","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5],"arg_names":["object","dtype","copy","order","subok","ndmin","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.bool","numpy._globals._CopyMode",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.int",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.array#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,5,5,5,5,5],"arg_names":["object","dtype","copy","order","subok","ndmin","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.array","name":"array","original_first_arg":"object","type":{".class":"CallableType","arg_kinds":[0,1,5,5,5,5,5],"arg_names":["object","dtype","copy","order","subok","ndmin","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._CopyMode",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.int",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.array","name":"array","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,5,5,5,5,5],"arg_names":["object","dtype","copy","order","subok","ndmin","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._CopyMode",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.int",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,5,5,3,5,5],"arg_names":["object","dtype","copy","order","subok","ndmin","like"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.array#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._CopyMode",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},"builtins.int",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.array#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.array#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,5,5,3,5,5],"arg_names":["object","dtype","copy","order","subok","ndmin","like"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.array#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._core.multiarray._SupportsArray"},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._CopyMode",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.int","value":0},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.array#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.array#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,5,5,5,5,5],"arg_names":["object","dtype","copy","order","subok","ndmin","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._CopyMode",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.int",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.array#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5],"arg_names":["object","dtype","copy","order","subok","ndmin","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.bool","numpy._globals._CopyMode",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.int",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.array#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,5,5,5,5,5],"arg_names":["object","dtype","copy","order","subok","ndmin","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._CopyMode",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.int",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"asanyarray":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.asanyarray","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,5,5,5],"arg_names":["a","dtype","order","device","copy","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.asanyarray","name":"asanyarray","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,5,5,5],"arg_names":["a","dtype","order","device","copy","like"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.asanyarray#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asanyarray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.asanyarray#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.asanyarray#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.asanyarray","name":"asanyarray","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,5,5,5],"arg_names":["a","dtype","order","device","copy","like"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.asanyarray#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asanyarray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.asanyarray#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.asanyarray#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,5,5,5],"arg_names":["a","dtype","order","device","copy","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.asanyarray","name":"asanyarray","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,5,5,5],"arg_names":["a","dtype","order","device","copy","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asanyarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.asanyarray#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.asanyarray","name":"asanyarray","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,5,5,5],"arg_names":["a","dtype","order","device","copy","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asanyarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.asanyarray#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,5,5,5],"arg_names":["a","dtype","order","device","copy","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.asanyarray","name":"asanyarray","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,5,5,5],"arg_names":["a","dtype","order","device","copy","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asanyarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.asanyarray#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.asanyarray","name":"asanyarray","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,5,5,5],"arg_names":["a","dtype","order","device","copy","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asanyarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.asanyarray#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,5,5,5],"arg_names":["a","dtype","order","device","copy","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.asanyarray","name":"asanyarray","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,5,5,5],"arg_names":["a","dtype","order","device","copy","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asanyarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.asanyarray","name":"asanyarray","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,5,5,5],"arg_names":["a","dtype","order","device","copy","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asanyarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,5,5,5],"arg_names":["a","dtype","order","device","copy","like"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.asanyarray#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asanyarray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.asanyarray#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.asanyarray#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,5,5,5],"arg_names":["a","dtype","order","device","copy","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asanyarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.asanyarray#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,5,5,5],"arg_names":["a","dtype","order","device","copy","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asanyarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.asanyarray#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,5,5,5],"arg_names":["a","dtype","order","device","copy","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asanyarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"asarray":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.asarray","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,5,5,5],"arg_names":["a","dtype","order","device","copy","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.asarray","name":"asarray","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,5,5,5],"arg_names":["a","dtype","order","device","copy","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.asarray#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.asarray","name":"asarray","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,5,5,5],"arg_names":["a","dtype","order","device","copy","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.asarray#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,5,5,5],"arg_names":["a","dtype","order","device","copy","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.asarray","name":"asarray","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,5,5,5],"arg_names":["a","dtype","order","device","copy","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.asarray#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.asarray","name":"asarray","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,5,5,5],"arg_names":["a","dtype","order","device","copy","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.asarray#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,5,5,5],"arg_names":["a","dtype","order","device","copy","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.asarray","name":"asarray","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,5,5,5],"arg_names":["a","dtype","order","device","copy","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.asarray","name":"asarray","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,5,5,5],"arg_names":["a","dtype","order","device","copy","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,5,5,5],"arg_names":["a","dtype","order","device","copy","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.asarray#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,5,5,5],"arg_names":["a","dtype","order","device","copy","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.asarray#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,5,5,5],"arg_names":["a","dtype","order","device","copy","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"ascontiguousarray":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.ascontiguousarray","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,5],"arg_names":["a","dtype","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.ascontiguousarray","name":"ascontiguousarray","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,5],"arg_names":["a","dtype","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ascontiguousarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.ascontiguousarray#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.ascontiguousarray","name":"ascontiguousarray","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,5],"arg_names":["a","dtype","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ascontiguousarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.ascontiguousarray#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5],"arg_names":["a","dtype","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.ascontiguousarray","name":"ascontiguousarray","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["a","dtype","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ascontiguousarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.ascontiguousarray#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.ascontiguousarray","name":"ascontiguousarray","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["a","dtype","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ascontiguousarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.ascontiguousarray#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,5],"arg_names":["a","dtype","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.ascontiguousarray","name":"ascontiguousarray","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,5],"arg_names":["a","dtype","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ascontiguousarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.ascontiguousarray","name":"ascontiguousarray","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,5],"arg_names":["a","dtype","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ascontiguousarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,5],"arg_names":["a","dtype","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ascontiguousarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.ascontiguousarray#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["a","dtype","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ascontiguousarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.ascontiguousarray#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,5],"arg_names":["a","dtype","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ascontiguousarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"asfortranarray":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.asfortranarray","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,5],"arg_names":["a","dtype","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.asfortranarray","name":"asfortranarray","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,5],"arg_names":["a","dtype","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asfortranarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.asfortranarray#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.asfortranarray","name":"asfortranarray","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,5],"arg_names":["a","dtype","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asfortranarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.asfortranarray#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5],"arg_names":["a","dtype","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.asfortranarray","name":"asfortranarray","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["a","dtype","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asfortranarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.asfortranarray#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.asfortranarray","name":"asfortranarray","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["a","dtype","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asfortranarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.asfortranarray#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,5],"arg_names":["a","dtype","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.asfortranarray","name":"asfortranarray","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,5],"arg_names":["a","dtype","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asfortranarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.asfortranarray","name":"asfortranarray","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,5],"arg_names":["a","dtype","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asfortranarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,5],"arg_names":["a","dtype","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asfortranarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.asfortranarray#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["a","dtype","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asfortranarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.asfortranarray#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,5],"arg_names":["a","dtype","like"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asfortranarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"bincount":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":[null,"weights","minlength"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.bincount","name":"bincount","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":[null,"weights","minlength"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"bincount","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"broadcast":{".class":"SymbolTableNode","cross_ref":"numpy.broadcast","kind":"Gdef"},"busday_count":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.busday_count","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1],"arg_names":["begindates","enddates","weekmask","holidays","busdaycal","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.busday_count","name":"busday_count","original_first_arg":"begindates","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["begindates","enddates","weekmask","holidays","busdaycal","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"datetime.date"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"datetime.date"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy.busdaycalendar",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"busday_count","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int_"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.busday_count","name":"busday_count","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["begindates","enddates","weekmask","holidays","busdaycal","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"datetime.date"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"datetime.date"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy.busdaycalendar",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"busday_count","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int_"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1],"arg_names":["begindates","enddates","weekmask","holidays","busdaycal","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.busday_count","name":"busday_count","original_first_arg":"begindates","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["begindates","enddates","weekmask","holidays","busdaycal","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy.busdaycalendar",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"busday_count","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.busday_count","name":"busday_count","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["begindates","enddates","weekmask","holidays","busdaycal","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy.busdaycalendar",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"busday_count","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1],"arg_names":["begindates","enddates","weekmask","holidays","busdaycal","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.busday_count","name":"busday_count","original_first_arg":"begindates","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["begindates","enddates","weekmask","holidays","busdaycal","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy.busdaycalendar",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.busday_count","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"busday_count","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.busday_count","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.busday_count","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.busday_count","name":"busday_count","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["begindates","enddates","weekmask","holidays","busdaycal","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy.busdaycalendar",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.busday_count","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"busday_count","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.busday_count","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.busday_count","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["begindates","enddates","weekmask","holidays","busdaycal","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"datetime.date"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"datetime.date"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy.busdaycalendar",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"busday_count","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int_"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["begindates","enddates","weekmask","holidays","busdaycal","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy.busdaycalendar",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"busday_count","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["begindates","enddates","weekmask","holidays","busdaycal","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy.busdaycalendar",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.busday_count","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"busday_count","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.busday_count","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.busday_count","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"busday_offset":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.busday_offset","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1],"arg_names":["dates","offsets","roll","weekmask","holidays","busdaycal","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.busday_offset","name":"busday_offset","original_first_arg":"dates","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":["dates","offsets","roll","weekmask","holidays","busdaycal","out"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"datetime.date"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"datetime.timedelta"],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.str","value":"raise"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy.busdaycalendar",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"busday_offset","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.busday_offset","name":"busday_offset","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":["dates","offsets","roll","weekmask","holidays","busdaycal","out"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"datetime.date"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"datetime.timedelta"],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.str","value":"raise"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy.busdaycalendar",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"busday_offset","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1],"arg_names":["dates","offsets","roll","weekmask","holidays","busdaycal","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.busday_offset","name":"busday_offset","original_first_arg":"dates","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":["dates","offsets","roll","weekmask","holidays","busdaycal","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.timedelta",{".class":"Instance","args":["datetime.timedelta"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.str","value":"raise"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy.busdaycalendar",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"busday_offset","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.busday_offset","name":"busday_offset","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":["dates","offsets","roll","weekmask","holidays","busdaycal","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.timedelta",{".class":"Instance","args":["datetime.timedelta"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.str","value":"raise"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy.busdaycalendar",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"busday_offset","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1],"arg_names":["dates","offsets","roll","weekmask","holidays","busdaycal","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.busday_offset","name":"busday_offset","original_first_arg":"dates","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":["dates","offsets","roll","weekmask","holidays","busdaycal","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.timedelta",{".class":"Instance","args":["datetime.timedelta"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.str","value":"raise"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy.busdaycalendar",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.busday_offset#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"busday_offset","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.busday_offset#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.busday_offset#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.busday_offset","name":"busday_offset","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":["dates","offsets","roll","weekmask","holidays","busdaycal","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.timedelta",{".class":"Instance","args":["datetime.timedelta"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.str","value":"raise"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy.busdaycalendar",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.busday_offset#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"busday_offset","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.busday_offset#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.busday_offset#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1,1],"arg_names":["dates","offsets","roll","weekmask","holidays","busdaycal","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.busday_offset","name":"busday_offset","original_first_arg":"dates","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1],"arg_names":["dates","offsets","roll","weekmask","holidays","busdaycal","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"datetime.date"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"datetime.timedelta"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy.busdaycalendar",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"busday_offset","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.busday_offset","name":"busday_offset","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1],"arg_names":["dates","offsets","roll","weekmask","holidays","busdaycal","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"datetime.date"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"datetime.timedelta"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy.busdaycalendar",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"busday_offset","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1,1],"arg_names":["dates","offsets","roll","weekmask","holidays","busdaycal","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.busday_offset","name":"busday_offset","original_first_arg":"dates","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1],"arg_names":["dates","offsets","roll","weekmask","holidays","busdaycal","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.timedelta",{".class":"Instance","args":["datetime.timedelta"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy.busdaycalendar",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"busday_offset","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.busday_offset","name":"busday_offset","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1],"arg_names":["dates","offsets","roll","weekmask","holidays","busdaycal","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.timedelta",{".class":"Instance","args":["datetime.timedelta"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy.busdaycalendar",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"busday_offset","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1,1],"arg_names":["dates","offsets","roll","weekmask","holidays","busdaycal","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.busday_offset","name":"busday_offset","original_first_arg":"dates","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1],"arg_names":["dates","offsets","roll","weekmask","holidays","busdaycal","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.timedelta",{".class":"Instance","args":["datetime.timedelta"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy.busdaycalendar",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.busday_offset","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"busday_offset","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.busday_offset","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.busday_offset","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.busday_offset","name":"busday_offset","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1],"arg_names":["dates","offsets","roll","weekmask","holidays","busdaycal","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.timedelta",{".class":"Instance","args":["datetime.timedelta"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy.busdaycalendar",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.busday_offset","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"busday_offset","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.busday_offset","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.busday_offset","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":["dates","offsets","roll","weekmask","holidays","busdaycal","out"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"datetime.date"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"datetime.timedelta"],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.str","value":"raise"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy.busdaycalendar",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"busday_offset","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":["dates","offsets","roll","weekmask","holidays","busdaycal","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.timedelta",{".class":"Instance","args":["datetime.timedelta"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.str","value":"raise"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy.busdaycalendar",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"busday_offset","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":["dates","offsets","roll","weekmask","holidays","busdaycal","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.timedelta",{".class":"Instance","args":["datetime.timedelta"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.str","value":"raise"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy.busdaycalendar",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.busday_offset#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"busday_offset","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.busday_offset#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.busday_offset#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1],"arg_names":["dates","offsets","roll","weekmask","holidays","busdaycal","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"datetime.date"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"datetime.timedelta"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy.busdaycalendar",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"busday_offset","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1],"arg_names":["dates","offsets","roll","weekmask","holidays","busdaycal","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.timedelta",{".class":"Instance","args":["datetime.timedelta"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy.busdaycalendar",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"busday_offset","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1],"arg_names":["dates","offsets","roll","weekmask","holidays","busdaycal","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.timedelta",{".class":"Instance","args":["datetime.timedelta"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy.busdaycalendar",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.busday_offset","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"busday_offset","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.busday_offset","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.busday_offset","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"busdaycalendar":{".class":"SymbolTableNode","cross_ref":"numpy.busdaycalendar","kind":"Gdef"},"c_einsum":{".class":"SymbolTableNode","cross_ref":"numpy._core.einsumfunc.einsum","kind":"Gdef"},"can_cast":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["from_","to","casting"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.can_cast","name":"can_cast","original_first_arg":"from_","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["from_","to","casting"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"can_cast","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"compare_chararrays":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.compare_chararrays","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["a1","a2","cmp","rstrip"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.compare_chararrays","name":"compare_chararrays","original_first_arg":"a1","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["a1","a2","cmp","rstrip"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"<"},{".class":"LiteralType","fallback":"builtins.str","value":"<="},{".class":"LiteralType","fallback":"builtins.str","value":"=="},{".class":"LiteralType","fallback":"builtins.str","value":">="},{".class":"LiteralType","fallback":"builtins.str","value":">"},{".class":"LiteralType","fallback":"builtins.str","value":"!="}],"uses_pep604_syntax":false},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"compare_chararrays","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.compare_chararrays","name":"compare_chararrays","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["a1","a2","cmp","rstrip"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"<"},{".class":"LiteralType","fallback":"builtins.str","value":"<="},{".class":"LiteralType","fallback":"builtins.str","value":"=="},{".class":"LiteralType","fallback":"builtins.str","value":">="},{".class":"LiteralType","fallback":"builtins.str","value":">"},{".class":"LiteralType","fallback":"builtins.str","value":"!="}],"uses_pep604_syntax":false},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"compare_chararrays","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["a1","a2","cmp","rstrip"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.compare_chararrays","name":"compare_chararrays","original_first_arg":"a1","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["a1","a2","cmp","rstrip"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"<"},{".class":"LiteralType","fallback":"builtins.str","value":"<="},{".class":"LiteralType","fallback":"builtins.str","value":"=="},{".class":"LiteralType","fallback":"builtins.str","value":">="},{".class":"LiteralType","fallback":"builtins.str","value":">"},{".class":"LiteralType","fallback":"builtins.str","value":"!="}],"uses_pep604_syntax":false},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"compare_chararrays","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.compare_chararrays","name":"compare_chararrays","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["a1","a2","cmp","rstrip"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"<"},{".class":"LiteralType","fallback":"builtins.str","value":"<="},{".class":"LiteralType","fallback":"builtins.str","value":"=="},{".class":"LiteralType","fallback":"builtins.str","value":">="},{".class":"LiteralType","fallback":"builtins.str","value":">"},{".class":"LiteralType","fallback":"builtins.str","value":"!="}],"uses_pep604_syntax":false},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"compare_chararrays","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["a1","a2","cmp","rstrip"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"<"},{".class":"LiteralType","fallback":"builtins.str","value":"<="},{".class":"LiteralType","fallback":"builtins.str","value":"=="},{".class":"LiteralType","fallback":"builtins.str","value":">="},{".class":"LiteralType","fallback":"builtins.str","value":">"},{".class":"LiteralType","fallback":"builtins.str","value":"!="}],"uses_pep604_syntax":false},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"compare_chararrays","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["a1","a2","cmp","rstrip"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"<"},{".class":"LiteralType","fallback":"builtins.str","value":"<="},{".class":"LiteralType","fallback":"builtins.str","value":"=="},{".class":"LiteralType","fallback":"builtins.str","value":">="},{".class":"LiteralType","fallback":"builtins.str","value":">"},{".class":"LiteralType","fallback":"builtins.str","value":"!="}],"uses_pep604_syntax":false},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"compare_chararrays","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"complexfloating":{".class":"SymbolTableNode","cross_ref":"numpy.complexfloating","kind":"Gdef","module_hidden":true,"module_public":false},"concatenate":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.concatenate","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,5,5],"arg_names":[null,"axis","out","dtype","casting"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.concatenate","name":"concatenate","original_first_arg":"arrays","type":{".class":"CallableType","arg_kinds":[0,1,1,5,5],"arg_names":[null,"axis","out","dtype","casting"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"concatenate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.concatenate#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.concatenate","name":"concatenate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,5,5],"arg_names":[null,"axis","out","dtype","casting"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"concatenate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.concatenate#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,3,5],"arg_names":[null,"axis","out","dtype","casting"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.concatenate","name":"concatenate","original_first_arg":"arrays","type":{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":[null,"axis","out","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"_typeshed.SupportsLenAndGetItem"},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"concatenate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.concatenate#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.concatenate","name":"concatenate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":[null,"axis","out","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"_typeshed.SupportsLenAndGetItem"},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"concatenate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.concatenate#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,5,5],"arg_names":[null,"axis","out","dtype","casting"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.concatenate","name":"concatenate","original_first_arg":"arrays","type":{".class":"CallableType","arg_kinds":[0,1,1,5,5],"arg_names":[null,"axis","out","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"_typeshed.SupportsLenAndGetItem"},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"concatenate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.concatenate","name":"concatenate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,5,5],"arg_names":[null,"axis","out","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"_typeshed.SupportsLenAndGetItem"},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"concatenate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,5,5],"arg_names":[null,"axis","out","dtype","casting"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.concatenate","name":"concatenate","original_first_arg":"arrays","type":{".class":"CallableType","arg_kinds":[0,1,1,5,5],"arg_names":[null,"axis","out","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"_typeshed.SupportsLenAndGetItem"},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.concatenate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"concatenate","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.concatenate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.concatenate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.concatenate","name":"concatenate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,5,5],"arg_names":[null,"axis","out","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"_typeshed.SupportsLenAndGetItem"},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.concatenate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"concatenate","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.concatenate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.concatenate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,5,5],"arg_names":[null,"axis","out","dtype","casting"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"concatenate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.concatenate#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":[null,"axis","out","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"_typeshed.SupportsLenAndGetItem"},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"concatenate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.concatenate#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,5,5],"arg_names":[null,"axis","out","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"_typeshed.SupportsLenAndGetItem"},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"concatenate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,5,5],"arg_names":[null,"axis","out","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"_typeshed.SupportsLenAndGetItem"},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.concatenate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"concatenate","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.concatenate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.concatenate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"copyto":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["dst","src","casting","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.copyto","name":"copyto","original_first_arg":"dst","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["dst","src","casting","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"copyto","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"correlate":{".class":"SymbolTableNode","cross_ref":"numpy._core.numeric.correlate","kind":"Gdef"},"correlate2":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy._core.multiarray.correlate2","name":"correlate2","setter_type":null,"type":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":"builtins.object","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"count_nonzero":{".class":"SymbolTableNode","cross_ref":"numpy._core.numeric.count_nonzero","kind":"Gdef"},"datetime64":{".class":"SymbolTableNode","cross_ref":"numpy.datetime64","kind":"Gdef","module_hidden":true,"module_public":false},"datetime_as_string":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.datetime_as_string","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["arr","unit","timezone","casting"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.datetime_as_string","name":"datetime_as_string","original_first_arg":"arr","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["arr","unit","timezone","casting"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"datetime.date"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"auto"},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"naive"},{".class":"LiteralType","fallback":"builtins.str","value":"UTC"},{".class":"LiteralType","fallback":"builtins.str","value":"local"},"datetime.tzinfo"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"datetime_as_string","ret_type":"numpy.str_","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.datetime_as_string","name":"datetime_as_string","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["arr","unit","timezone","casting"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"datetime.date"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"auto"},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"naive"},{".class":"LiteralType","fallback":"builtins.str","value":"UTC"},{".class":"LiteralType","fallback":"builtins.str","value":"local"},"datetime.tzinfo"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"datetime_as_string","ret_type":"numpy.str_","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["arr","unit","timezone","casting"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.datetime_as_string","name":"datetime_as_string","original_first_arg":"arr","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["arr","unit","timezone","casting"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"auto"},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"naive"},{".class":"LiteralType","fallback":"builtins.str","value":"UTC"},{".class":"LiteralType","fallback":"builtins.str","value":"local"},"datetime.tzinfo"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"datetime_as_string","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.datetime_as_string","name":"datetime_as_string","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["arr","unit","timezone","casting"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"auto"},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"naive"},{".class":"LiteralType","fallback":"builtins.str","value":"UTC"},{".class":"LiteralType","fallback":"builtins.str","value":"local"},"datetime.tzinfo"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"datetime_as_string","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["arr","unit","timezone","casting"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"datetime.date"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"auto"},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"naive"},{".class":"LiteralType","fallback":"builtins.str","value":"UTC"},{".class":"LiteralType","fallback":"builtins.str","value":"local"},"datetime.tzinfo"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"datetime_as_string","ret_type":"numpy.str_","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["arr","unit","timezone","casting"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"auto"},{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"naive"},{".class":"LiteralType","fallback":"builtins.str","value":"UTC"},{".class":"LiteralType","fallback":"builtins.str","value":"local"},"datetime.tzinfo"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"datetime_as_string","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"datetime_data":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.datetime_data","name":"datetime_data","original_first_arg":"dtype","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"datetime_data","ret_type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"dot":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.dot","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","b","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.dot","name":"dot","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dot","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.dot","name":"dot","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dot","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["a","b","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.dot","name":"dot","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["a","b","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.dot","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dot","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.dot","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.dot","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.dot","name":"dot","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["a","b","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.dot","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dot","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.dot","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.dot","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dot","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["a","b","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.dot","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dot","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.dot","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.dot","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"dragon4_positional":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy._core.multiarray.dragon4_positional","name":"dragon4_positional","setter_type":null,"type":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":"builtins.object","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"dragon4_scientific":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy._core.multiarray.dragon4_scientific","name":"dragon4_scientific","setter_type":null,"type":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":"builtins.object","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"dt":{".class":"SymbolTableNode","cross_ref":"datetime","kind":"Gdef","module_hidden":true,"module_public":false},"dtype":{".class":"SymbolTableNode","cross_ref":"numpy.dtype","kind":"Gdef"},"empty":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy._core.multiarray.empty","name":"empty","setter_type":null,"type":"numpy._core.multiarray._ConstructorEmpty"}},"empty_like":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.empty_like","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,5],"arg_names":["prototype","dtype","order","subok","shape","device"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.empty_like","name":"empty_like","original_first_arg":"prototype","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["prototype","dtype","order","subok","shape","device"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.empty_like#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"empty_like","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.empty_like#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.empty_like#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.empty_like","name":"empty_like","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["prototype","dtype","order","subok","shape","device"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.empty_like#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"empty_like","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.empty_like#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.empty_like#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,5],"arg_names":["prototype","dtype","order","subok","shape","device"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.empty_like","name":"empty_like","original_first_arg":"prototype","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["prototype","dtype","order","subok","shape","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"empty_like","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.empty_like#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.empty_like","name":"empty_like","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["prototype","dtype","order","subok","shape","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"empty_like","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.empty_like#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,5],"arg_names":["prototype","dtype","order","subok","shape","device"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.empty_like","name":"empty_like","original_first_arg":"prototype","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,5],"arg_names":["prototype","dtype","order","subok","shape","device"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"empty_like","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.empty_like#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.empty_like","name":"empty_like","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,5],"arg_names":["prototype","dtype","order","subok","shape","device"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"empty_like","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.empty_like#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,5],"arg_names":["prototype","dtype","order","subok","shape","device"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.empty_like","name":"empty_like","original_first_arg":"prototype","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["prototype","dtype","order","subok","shape","device"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"empty_like","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.empty_like","name":"empty_like","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["prototype","dtype","order","subok","shape","device"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"empty_like","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["prototype","dtype","order","subok","shape","device"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.empty_like#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"empty_like","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.empty_like#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.empty_like#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["prototype","dtype","order","subok","shape","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"empty_like","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.empty_like#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,5],"arg_names":["prototype","dtype","order","subok","shape","device"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"empty_like","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.empty_like#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["prototype","dtype","order","subok","shape","device"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"empty_like","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"error":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._core.multiarray.error","line":363,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":"builtins.Exception"}},"final":{".class":"SymbolTableNode","cross_ref":"typing.final","kind":"Gdef","module_hidden":true,"module_public":false},"flagsobj":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._core.multiarray.flagsobj","name":"flagsobj","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_final"],"fullname":"numpy._core.multiarray.flagsobj","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._core.multiarray","mro":["numpy._core.multiarray.flagsobj","builtins.object"],"names":{".class":"SymbolTable","__getitem__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core.multiarray.flagsobj.__getitem__","name":"__getitem__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy._core.multiarray.flagsobj",{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of flagsobj","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__hash__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready"],"fullname":"numpy._core.multiarray.flagsobj.__hash__","name":"__hash__","setter_type":null,"type":{".class":"NoneType"}}},"__setitem__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":[null,null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core.multiarray.flagsobj.__setitem__","name":"__setitem__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,null,null],"arg_types":["numpy._core.multiarray.flagsobj",{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__setitem__ of flagsobj","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"aligned":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy._core.multiarray.flagsobj.aligned","name":"aligned","setter_type":null,"type":"builtins.bool"}},"behaved":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._core.multiarray.flagsobj.behaved","name":"behaved","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy._core.multiarray.flagsobj"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"behaved of flagsobj","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._core.multiarray.flagsobj.behaved","name":"behaved","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy._core.multiarray.flagsobj"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"behaved of flagsobj","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"c_contiguous":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._core.multiarray.flagsobj.c_contiguous","name":"c_contiguous","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy._core.multiarray.flagsobj"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"c_contiguous of flagsobj","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._core.multiarray.flagsobj.c_contiguous","name":"c_contiguous","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy._core.multiarray.flagsobj"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"c_contiguous of flagsobj","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"carray":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._core.multiarray.flagsobj.carray","name":"carray","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy._core.multiarray.flagsobj"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"carray of flagsobj","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._core.multiarray.flagsobj.carray","name":"carray","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy._core.multiarray.flagsobj"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"carray of flagsobj","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"contiguous":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._core.multiarray.flagsobj.contiguous","name":"contiguous","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy._core.multiarray.flagsobj"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"contiguous of flagsobj","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._core.multiarray.flagsobj.contiguous","name":"contiguous","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy._core.multiarray.flagsobj"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"contiguous of flagsobj","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"f_contiguous":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._core.multiarray.flagsobj.f_contiguous","name":"f_contiguous","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy._core.multiarray.flagsobj"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"f_contiguous of flagsobj","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._core.multiarray.flagsobj.f_contiguous","name":"f_contiguous","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy._core.multiarray.flagsobj"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"f_contiguous of flagsobj","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"farray":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._core.multiarray.flagsobj.farray","name":"farray","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy._core.multiarray.flagsobj"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"farray of flagsobj","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._core.multiarray.flagsobj.farray","name":"farray","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy._core.multiarray.flagsobj"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"farray of flagsobj","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"fnc":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._core.multiarray.flagsobj.fnc","name":"fnc","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy._core.multiarray.flagsobj"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fnc of flagsobj","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._core.multiarray.flagsobj.fnc","name":"fnc","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy._core.multiarray.flagsobj"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fnc of flagsobj","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"forc":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._core.multiarray.flagsobj.forc","name":"forc","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy._core.multiarray.flagsobj"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"forc of flagsobj","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._core.multiarray.flagsobj.forc","name":"forc","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy._core.multiarray.flagsobj"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"forc of flagsobj","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"fortran":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._core.multiarray.flagsobj.fortran","name":"fortran","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy._core.multiarray.flagsobj"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fortran of flagsobj","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._core.multiarray.flagsobj.fortran","name":"fortran","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy._core.multiarray.flagsobj"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fortran of flagsobj","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"num":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._core.multiarray.flagsobj.num","name":"num","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy._core.multiarray.flagsobj"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"num of flagsobj","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._core.multiarray.flagsobj.num","name":"num","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy._core.multiarray.flagsobj"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"num of flagsobj","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"owndata":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._core.multiarray.flagsobj.owndata","name":"owndata","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy._core.multiarray.flagsobj"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"owndata of flagsobj","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._core.multiarray.flagsobj.owndata","name":"owndata","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy._core.multiarray.flagsobj"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"owndata of flagsobj","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"writeable":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy._core.multiarray.flagsobj.writeable","name":"writeable","setter_type":null,"type":"builtins.bool"}},"writebackifcopy":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy._core.multiarray.flagsobj.writebackifcopy","name":"writebackifcopy","setter_type":null,"type":"builtins.bool"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray.flagsobj.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy._core.multiarray.flagsobj","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"flatiter":{".class":"SymbolTableNode","cross_ref":"numpy.flatiter","kind":"Gdef"},"float64":{".class":"SymbolTableNode","cross_ref":"numpy.float64","kind":"Gdef","module_hidden":true,"module_public":false},"floating":{".class":"SymbolTableNode","cross_ref":"numpy.floating","kind":"Gdef","module_hidden":true,"module_public":false},"format_longfloat":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x","precision"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.format_longfloat","name":"format_longfloat","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x","precision"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"format_longfloat","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"from_dlpack":{".class":"SymbolTableNode","cross_ref":"numpy.from_dlpack","kind":"Gdef"},"frombuffer":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.frombuffer","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,5],"arg_names":["buffer","dtype","count","offset","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.frombuffer","name":"frombuffer","original_first_arg":"buffer","type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["buffer","dtype","count","offset","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"typing.SupportsIndex","typing.SupportsIndex",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frombuffer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.frombuffer","name":"frombuffer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["buffer","dtype","count","offset","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"typing.SupportsIndex","typing.SupportsIndex",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frombuffer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,5],"arg_names":["buffer","dtype","count","offset","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.frombuffer","name":"frombuffer","original_first_arg":"buffer","type":{".class":"CallableType","arg_kinds":[0,0,1,1,5],"arg_names":["buffer","dtype","count","offset","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","typing.SupportsIndex",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frombuffer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.frombuffer#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.frombuffer","name":"frombuffer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,5],"arg_names":["buffer","dtype","count","offset","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","typing.SupportsIndex",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frombuffer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.frombuffer#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,5],"arg_names":["buffer","dtype","count","offset","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.frombuffer","name":"frombuffer","original_first_arg":"buffer","type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["buffer","dtype","count","offset","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"typing.SupportsIndex","typing.SupportsIndex",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frombuffer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.frombuffer","name":"frombuffer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["buffer","dtype","count","offset","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"typing.SupportsIndex","typing.SupportsIndex",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frombuffer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["buffer","dtype","count","offset","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"typing.SupportsIndex","typing.SupportsIndex",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frombuffer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,5],"arg_names":["buffer","dtype","count","offset","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","typing.SupportsIndex",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frombuffer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.frombuffer#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["buffer","dtype","count","offset","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"typing.SupportsIndex","typing.SupportsIndex",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frombuffer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"fromfile":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.fromfile","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,5],"arg_names":["file","dtype","count","sep","offset","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.fromfile","name":"fromfile","original_first_arg":"file","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["file","dtype","count","sep","offset","like"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.StrOrBytesPath"},"numpy._SupportsFileMethods"],"uses_pep604_syntax":true},{".class":"NoneType"},"typing.SupportsIndex","builtins.str","typing.SupportsIndex",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromfile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.fromfile","name":"fromfile","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["file","dtype","count","sep","offset","like"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.StrOrBytesPath"},"numpy._SupportsFileMethods"],"uses_pep604_syntax":true},{".class":"NoneType"},"typing.SupportsIndex","builtins.str","typing.SupportsIndex",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromfile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,5],"arg_names":["file","dtype","count","sep","offset","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.fromfile","name":"fromfile","original_first_arg":"file","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,5],"arg_names":["file","dtype","count","sep","offset","like"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.StrOrBytesPath"},"numpy._SupportsFileMethods"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.str","typing.SupportsIndex",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromfile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.fromfile#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.fromfile","name":"fromfile","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,5],"arg_names":["file","dtype","count","sep","offset","like"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.StrOrBytesPath"},"numpy._SupportsFileMethods"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.str","typing.SupportsIndex",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromfile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.fromfile#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,5],"arg_names":["file","dtype","count","sep","offset","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.fromfile","name":"fromfile","original_first_arg":"file","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["file","dtype","count","sep","offset","like"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.StrOrBytesPath"},"numpy._SupportsFileMethods"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"typing.SupportsIndex","builtins.str","typing.SupportsIndex",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromfile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.fromfile","name":"fromfile","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["file","dtype","count","sep","offset","like"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.StrOrBytesPath"},"numpy._SupportsFileMethods"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"typing.SupportsIndex","builtins.str","typing.SupportsIndex",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromfile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["file","dtype","count","sep","offset","like"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.StrOrBytesPath"},"numpy._SupportsFileMethods"],"uses_pep604_syntax":true},{".class":"NoneType"},"typing.SupportsIndex","builtins.str","typing.SupportsIndex",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromfile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,5],"arg_names":["file","dtype","count","sep","offset","like"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.StrOrBytesPath"},"numpy._SupportsFileMethods"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.str","typing.SupportsIndex",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromfile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.fromfile#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["file","dtype","count","sep","offset","like"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.StrOrBytesPath"},"numpy._SupportsFileMethods"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"typing.SupportsIndex","builtins.str","typing.SupportsIndex",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromfile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"fromiter":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.fromiter","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,5],"arg_names":["iter","dtype","count","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.fromiter","name":"fromiter","original_first_arg":"iter","type":{".class":"CallableType","arg_kinds":[0,0,1,5],"arg_names":["iter","dtype","count","like"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromiter","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.fromiter#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.fromiter","name":"fromiter","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,5],"arg_names":["iter","dtype","count","like"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromiter","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.fromiter#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,5],"arg_names":["iter","dtype","count","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.fromiter","name":"fromiter","original_first_arg":"iter","type":{".class":"CallableType","arg_kinds":[0,0,1,5],"arg_names":["iter","dtype","count","like"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromiter","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.fromiter","name":"fromiter","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,5],"arg_names":["iter","dtype","count","like"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromiter","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,5],"arg_names":["iter","dtype","count","like"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromiter","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.fromiter#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,5],"arg_names":["iter","dtype","count","like"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromiter","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"frompyfunc":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.frompyfunc","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5],"arg_names":[null,"nin","nout","identity"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.frompyfunc","name":"frompyfunc","original_first_arg":"func","type":{".class":"CallableType","arg_kinds":[0,0,0,5],"arg_names":[null,"nin","nout","identity"],"arg_types":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#0","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frompyfunc","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#0","upper_bound":"builtins.object","values":[],"variance":0},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#0","upper_bound":"builtins.object","values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.frompyfunc","name":"frompyfunc","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,5],"arg_names":[null,"nin","nout","identity"],"arg_types":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#0","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frompyfunc","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#0","upper_bound":"builtins.object","values":[],"variance":0},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#0","upper_bound":"builtins.object","values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,3],"arg_names":[null,"nin","nout","identity"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.frompyfunc","name":"frompyfunc","original_first_arg":"func","type":{".class":"CallableType","arg_kinds":[0,0,0,3],"arg_names":[null,"nin","nout","identity"],"arg_types":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#1","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","id":-2,"name":"_IDType","namespace":"numpy._core.multiarray.frompyfunc#1","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frompyfunc","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#1","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","id":-2,"name":"_IDType","namespace":"numpy._core.multiarray.frompyfunc#1","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#1","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","id":-2,"name":"_IDType","namespace":"numpy._core.multiarray.frompyfunc#1","upper_bound":"builtins.object","values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.frompyfunc","name":"frompyfunc","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,3],"arg_names":[null,"nin","nout","identity"],"arg_types":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#1","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","id":-2,"name":"_IDType","namespace":"numpy._core.multiarray.frompyfunc#1","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frompyfunc","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#1","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","id":-2,"name":"_IDType","namespace":"numpy._core.multiarray.frompyfunc#1","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#1","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","id":-2,"name":"_IDType","namespace":"numpy._core.multiarray.frompyfunc#1","upper_bound":"builtins.object","values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5],"arg_names":[null,"nin","nout","identity"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.frompyfunc","name":"frompyfunc","original_first_arg":"func","type":{".class":"CallableType","arg_kinds":[0,0,0,5],"arg_names":[null,"nin","nout","identity"],"arg_types":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#2","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"LiteralType","fallback":"builtins.int","value":2},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frompyfunc","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#2","upper_bound":"builtins.object","values":[],"variance":0},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#2","upper_bound":"builtins.object","values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.frompyfunc","name":"frompyfunc","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,5],"arg_names":[null,"nin","nout","identity"],"arg_types":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#2","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"LiteralType","fallback":"builtins.int","value":2},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frompyfunc","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#2","upper_bound":"builtins.object","values":[],"variance":0},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#2","upper_bound":"builtins.object","values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,3],"arg_names":[null,"nin","nout","identity"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.frompyfunc","name":"frompyfunc","original_first_arg":"func","type":{".class":"CallableType","arg_kinds":[0,0,0,3],"arg_names":[null,"nin","nout","identity"],"arg_types":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#3","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"LiteralType","fallback":"builtins.int","value":2},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","id":-2,"name":"_IDType","namespace":"numpy._core.multiarray.frompyfunc#3","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frompyfunc","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#3","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","id":-2,"name":"_IDType","namespace":"numpy._core.multiarray.frompyfunc#3","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#3","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","id":-2,"name":"_IDType","namespace":"numpy._core.multiarray.frompyfunc#3","upper_bound":"builtins.object","values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.frompyfunc","name":"frompyfunc","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,3],"arg_names":[null,"nin","nout","identity"],"arg_types":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#3","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"LiteralType","fallback":"builtins.int","value":2},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","id":-2,"name":"_IDType","namespace":"numpy._core.multiarray.frompyfunc#3","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frompyfunc","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#3","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","id":-2,"name":"_IDType","namespace":"numpy._core.multiarray.frompyfunc#3","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#3","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","id":-2,"name":"_IDType","namespace":"numpy._core.multiarray.frompyfunc#3","upper_bound":"builtins.object","values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5],"arg_names":[null,"nin","nout","identity"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.frompyfunc","name":"frompyfunc","original_first_arg":"func","type":{".class":"CallableType","arg_kinds":[0,0,0,5],"arg_names":[null,"nin","nout","identity"],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#4","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","id":-2,"name":"_Nin","namespace":"numpy._core.multiarray.frompyfunc#4","upper_bound":"builtins.int","values":[],"variance":0},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frompyfunc","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#4","upper_bound":"builtins.object","values":[],"variance":0},{".class":"NoneType"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","id":-2,"name":"_Nin","namespace":"numpy._core.multiarray.frompyfunc#4","upper_bound":"builtins.int","values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#4","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","id":-2,"name":"_Nin","namespace":"numpy._core.multiarray.frompyfunc#4","upper_bound":"builtins.int","values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.frompyfunc","name":"frompyfunc","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,5],"arg_names":[null,"nin","nout","identity"],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#4","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","id":-2,"name":"_Nin","namespace":"numpy._core.multiarray.frompyfunc#4","upper_bound":"builtins.int","values":[],"variance":0},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frompyfunc","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#4","upper_bound":"builtins.object","values":[],"variance":0},{".class":"NoneType"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","id":-2,"name":"_Nin","namespace":"numpy._core.multiarray.frompyfunc#4","upper_bound":"builtins.int","values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#4","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","id":-2,"name":"_Nin","namespace":"numpy._core.multiarray.frompyfunc#4","upper_bound":"builtins.int","values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,3],"arg_names":[null,"nin","nout","identity"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.frompyfunc","name":"frompyfunc","original_first_arg":"func","type":{".class":"CallableType","arg_kinds":[0,0,0,3],"arg_names":[null,"nin","nout","identity"],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#5","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","id":-2,"name":"_Nin","namespace":"numpy._core.multiarray.frompyfunc#5","upper_bound":"builtins.int","values":[],"variance":0},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","id":-3,"name":"_IDType","namespace":"numpy._core.multiarray.frompyfunc#5","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frompyfunc","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#5","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","id":-3,"name":"_IDType","namespace":"numpy._core.multiarray.frompyfunc#5","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","id":-2,"name":"_Nin","namespace":"numpy._core.multiarray.frompyfunc#5","upper_bound":"builtins.int","values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#5","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","id":-2,"name":"_Nin","namespace":"numpy._core.multiarray.frompyfunc#5","upper_bound":"builtins.int","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","id":-3,"name":"_IDType","namespace":"numpy._core.multiarray.frompyfunc#5","upper_bound":"builtins.object","values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.frompyfunc","name":"frompyfunc","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,3],"arg_names":[null,"nin","nout","identity"],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#5","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","id":-2,"name":"_Nin","namespace":"numpy._core.multiarray.frompyfunc#5","upper_bound":"builtins.int","values":[],"variance":0},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","id":-3,"name":"_IDType","namespace":"numpy._core.multiarray.frompyfunc#5","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frompyfunc","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#5","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","id":-3,"name":"_IDType","namespace":"numpy._core.multiarray.frompyfunc#5","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","id":-2,"name":"_Nin","namespace":"numpy._core.multiarray.frompyfunc#5","upper_bound":"builtins.int","values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#5","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","id":-2,"name":"_Nin","namespace":"numpy._core.multiarray.frompyfunc#5","upper_bound":"builtins.int","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","id":-3,"name":"_IDType","namespace":"numpy._core.multiarray.frompyfunc#5","upper_bound":"builtins.object","values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5],"arg_names":[null,"nin","nout","identity"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.frompyfunc","name":"frompyfunc","original_first_arg":"func","type":{".class":"CallableType","arg_kinds":[0,0,0,5],"arg_names":[null,"nin","nout","identity"],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","id":-2,"name":"_Nin","namespace":"numpy._core.multiarray.frompyfunc#6","upper_bound":"builtins.int","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nout","id":-3,"name":"_Nout","namespace":"numpy._core.multiarray.frompyfunc#6","upper_bound":"builtins.int","values":[],"variance":0},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frompyfunc","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#6","upper_bound":"builtins.object","values":[],"variance":0},{".class":"NoneType"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","id":-2,"name":"_Nin","namespace":"numpy._core.multiarray.frompyfunc#6","upper_bound":"builtins.int","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nout","id":-3,"name":"_Nout","namespace":"numpy._core.multiarray.frompyfunc#6","upper_bound":"builtins.int","values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#6","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","id":-2,"name":"_Nin","namespace":"numpy._core.multiarray.frompyfunc#6","upper_bound":"builtins.int","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nout","id":-3,"name":"_Nout","namespace":"numpy._core.multiarray.frompyfunc#6","upper_bound":"builtins.int","values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.frompyfunc","name":"frompyfunc","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,5],"arg_names":[null,"nin","nout","identity"],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","id":-2,"name":"_Nin","namespace":"numpy._core.multiarray.frompyfunc#6","upper_bound":"builtins.int","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nout","id":-3,"name":"_Nout","namespace":"numpy._core.multiarray.frompyfunc#6","upper_bound":"builtins.int","values":[],"variance":0},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frompyfunc","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#6","upper_bound":"builtins.object","values":[],"variance":0},{".class":"NoneType"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","id":-2,"name":"_Nin","namespace":"numpy._core.multiarray.frompyfunc#6","upper_bound":"builtins.int","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nout","id":-3,"name":"_Nout","namespace":"numpy._core.multiarray.frompyfunc#6","upper_bound":"builtins.int","values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#6","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","id":-2,"name":"_Nin","namespace":"numpy._core.multiarray.frompyfunc#6","upper_bound":"builtins.int","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nout","id":-3,"name":"_Nout","namespace":"numpy._core.multiarray.frompyfunc#6","upper_bound":"builtins.int","values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,3],"arg_names":[null,"nin","nout","identity"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.frompyfunc","name":"frompyfunc","original_first_arg":"func","type":{".class":"CallableType","arg_kinds":[0,0,0,3],"arg_names":[null,"nin","nout","identity"],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","id":-2,"name":"_Nin","namespace":"numpy._core.multiarray.frompyfunc#7","upper_bound":"builtins.int","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nout","id":-3,"name":"_Nout","namespace":"numpy._core.multiarray.frompyfunc#7","upper_bound":"builtins.int","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","id":-4,"name":"_IDType","namespace":"numpy._core.multiarray.frompyfunc#7","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frompyfunc","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#7","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","id":-4,"name":"_IDType","namespace":"numpy._core.multiarray.frompyfunc#7","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","id":-2,"name":"_Nin","namespace":"numpy._core.multiarray.frompyfunc#7","upper_bound":"builtins.int","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nout","id":-3,"name":"_Nout","namespace":"numpy._core.multiarray.frompyfunc#7","upper_bound":"builtins.int","values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#7","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","id":-2,"name":"_Nin","namespace":"numpy._core.multiarray.frompyfunc#7","upper_bound":"builtins.int","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nout","id":-3,"name":"_Nout","namespace":"numpy._core.multiarray.frompyfunc#7","upper_bound":"builtins.int","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","id":-4,"name":"_IDType","namespace":"numpy._core.multiarray.frompyfunc#7","upper_bound":"builtins.object","values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.frompyfunc","name":"frompyfunc","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,3],"arg_names":[null,"nin","nout","identity"],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","id":-2,"name":"_Nin","namespace":"numpy._core.multiarray.frompyfunc#7","upper_bound":"builtins.int","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nout","id":-3,"name":"_Nout","namespace":"numpy._core.multiarray.frompyfunc#7","upper_bound":"builtins.int","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","id":-4,"name":"_IDType","namespace":"numpy._core.multiarray.frompyfunc#7","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frompyfunc","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#7","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","id":-4,"name":"_IDType","namespace":"numpy._core.multiarray.frompyfunc#7","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","id":-2,"name":"_Nin","namespace":"numpy._core.multiarray.frompyfunc#7","upper_bound":"builtins.int","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nout","id":-3,"name":"_Nout","namespace":"numpy._core.multiarray.frompyfunc#7","upper_bound":"builtins.int","values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#7","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","id":-2,"name":"_Nin","namespace":"numpy._core.multiarray.frompyfunc#7","upper_bound":"builtins.int","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nout","id":-3,"name":"_Nout","namespace":"numpy._core.multiarray.frompyfunc#7","upper_bound":"builtins.int","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","id":-4,"name":"_IDType","namespace":"numpy._core.multiarray.frompyfunc#7","upper_bound":"builtins.object","values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5],"arg_names":[null,"nin","nout","identity"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.frompyfunc","name":"frompyfunc","original_first_arg":"func","type":{".class":"CallableType","arg_kinds":[0,0,0,5],"arg_names":[null,"nin","nout","identity"],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"typing.SupportsIndex","typing.SupportsIndex",{".class":"UnionType","items":["builtins.object",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frompyfunc","ret_type":"numpy.ufunc","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.frompyfunc","name":"frompyfunc","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,5],"arg_names":[null,"nin","nout","identity"],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"typing.SupportsIndex","typing.SupportsIndex",{".class":"UnionType","items":["builtins.object",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frompyfunc","ret_type":"numpy.ufunc","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,5],"arg_names":[null,"nin","nout","identity"],"arg_types":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#0","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frompyfunc","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#0","upper_bound":"builtins.object","values":[],"variance":0},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#0","upper_bound":"builtins.object","values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,3],"arg_names":[null,"nin","nout","identity"],"arg_types":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#1","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","id":-2,"name":"_IDType","namespace":"numpy._core.multiarray.frompyfunc#1","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frompyfunc","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#1","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","id":-2,"name":"_IDType","namespace":"numpy._core.multiarray.frompyfunc#1","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#1","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","id":-2,"name":"_IDType","namespace":"numpy._core.multiarray.frompyfunc#1","upper_bound":"builtins.object","values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,5],"arg_names":[null,"nin","nout","identity"],"arg_types":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#2","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"LiteralType","fallback":"builtins.int","value":2},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frompyfunc","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#2","upper_bound":"builtins.object","values":[],"variance":0},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#2","upper_bound":"builtins.object","values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,3],"arg_names":[null,"nin","nout","identity"],"arg_types":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#3","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"LiteralType","fallback":"builtins.int","value":2},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","id":-2,"name":"_IDType","namespace":"numpy._core.multiarray.frompyfunc#3","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frompyfunc","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#3","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","id":-2,"name":"_IDType","namespace":"numpy._core.multiarray.frompyfunc#3","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#3","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","id":-2,"name":"_IDType","namespace":"numpy._core.multiarray.frompyfunc#3","upper_bound":"builtins.object","values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,5],"arg_names":[null,"nin","nout","identity"],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#4","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","id":-2,"name":"_Nin","namespace":"numpy._core.multiarray.frompyfunc#4","upper_bound":"builtins.int","values":[],"variance":0},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frompyfunc","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#4","upper_bound":"builtins.object","values":[],"variance":0},{".class":"NoneType"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","id":-2,"name":"_Nin","namespace":"numpy._core.multiarray.frompyfunc#4","upper_bound":"builtins.int","values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#4","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","id":-2,"name":"_Nin","namespace":"numpy._core.multiarray.frompyfunc#4","upper_bound":"builtins.int","values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,3],"arg_names":[null,"nin","nout","identity"],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#5","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","id":-2,"name":"_Nin","namespace":"numpy._core.multiarray.frompyfunc#5","upper_bound":"builtins.int","values":[],"variance":0},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","id":-3,"name":"_IDType","namespace":"numpy._core.multiarray.frompyfunc#5","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frompyfunc","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#5","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","id":-3,"name":"_IDType","namespace":"numpy._core.multiarray.frompyfunc#5","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","id":-2,"name":"_Nin","namespace":"numpy._core.multiarray.frompyfunc#5","upper_bound":"builtins.int","values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#5","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","id":-2,"name":"_Nin","namespace":"numpy._core.multiarray.frompyfunc#5","upper_bound":"builtins.int","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","id":-3,"name":"_IDType","namespace":"numpy._core.multiarray.frompyfunc#5","upper_bound":"builtins.object","values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,5],"arg_names":[null,"nin","nout","identity"],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","id":-2,"name":"_Nin","namespace":"numpy._core.multiarray.frompyfunc#6","upper_bound":"builtins.int","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nout","id":-3,"name":"_Nout","namespace":"numpy._core.multiarray.frompyfunc#6","upper_bound":"builtins.int","values":[],"variance":0},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frompyfunc","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#6","upper_bound":"builtins.object","values":[],"variance":0},{".class":"NoneType"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","id":-2,"name":"_Nin","namespace":"numpy._core.multiarray.frompyfunc#6","upper_bound":"builtins.int","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nout","id":-3,"name":"_Nout","namespace":"numpy._core.multiarray.frompyfunc#6","upper_bound":"builtins.int","values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#6","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","id":-2,"name":"_Nin","namespace":"numpy._core.multiarray.frompyfunc#6","upper_bound":"builtins.int","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nout","id":-3,"name":"_Nout","namespace":"numpy._core.multiarray.frompyfunc#6","upper_bound":"builtins.int","values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,3],"arg_names":[null,"nin","nout","identity"],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","id":-2,"name":"_Nin","namespace":"numpy._core.multiarray.frompyfunc#7","upper_bound":"builtins.int","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nout","id":-3,"name":"_Nout","namespace":"numpy._core.multiarray.frompyfunc#7","upper_bound":"builtins.int","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","id":-4,"name":"_IDType","namespace":"numpy._core.multiarray.frompyfunc#7","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frompyfunc","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#7","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","id":-4,"name":"_IDType","namespace":"numpy._core.multiarray.frompyfunc#7","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","id":-2,"name":"_Nin","namespace":"numpy._core.multiarray.frompyfunc#7","upper_bound":"builtins.int","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nout","id":-3,"name":"_Nout","namespace":"numpy._core.multiarray.frompyfunc#7","upper_bound":"builtins.int","values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ReturnType","id":-1,"name":"_ReturnType","namespace":"numpy._core.multiarray.frompyfunc#7","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nin","id":-2,"name":"_Nin","namespace":"numpy._core.multiarray.frompyfunc#7","upper_bound":"builtins.int","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._Nout","id":-3,"name":"_Nout","namespace":"numpy._core.multiarray.frompyfunc#7","upper_bound":"builtins.int","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._IDType","id":-4,"name":"_IDType","namespace":"numpy._core.multiarray.frompyfunc#7","upper_bound":"builtins.object","values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,5],"arg_names":[null,"nin","nout","identity"],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"typing.SupportsIndex","typing.SupportsIndex",{".class":"UnionType","items":["builtins.object",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frompyfunc","ret_type":"numpy.ufunc","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"fromstring":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.fromstring","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,3,5],"arg_names":["string","dtype","count","sep","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.fromstring","name":"fromstring","original_first_arg":"string","type":{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["string","dtype","count","sep","like"],"arg_types":[{".class":"UnionType","items":["builtins.str","builtins.bytes"],"uses_pep604_syntax":true},{".class":"NoneType"},"typing.SupportsIndex","builtins.str",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromstring","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.fromstring","name":"fromstring","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["string","dtype","count","sep","like"],"arg_types":[{".class":"UnionType","items":["builtins.str","builtins.bytes"],"uses_pep604_syntax":true},{".class":"NoneType"},"typing.SupportsIndex","builtins.str",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromstring","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,3,5],"arg_names":["string","dtype","count","sep","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.fromstring","name":"fromstring","original_first_arg":"string","type":{".class":"CallableType","arg_kinds":[0,0,1,3,5],"arg_names":["string","dtype","count","sep","like"],"arg_types":[{".class":"UnionType","items":["builtins.str","builtins.bytes"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.str",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromstring","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.fromstring#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.fromstring","name":"fromstring","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,3,5],"arg_names":["string","dtype","count","sep","like"],"arg_types":[{".class":"UnionType","items":["builtins.str","builtins.bytes"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.str",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromstring","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.fromstring#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,3,5],"arg_names":["string","dtype","count","sep","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.fromstring","name":"fromstring","original_first_arg":"string","type":{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["string","dtype","count","sep","like"],"arg_types":[{".class":"UnionType","items":["builtins.str","builtins.bytes"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"typing.SupportsIndex","builtins.str",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromstring","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.fromstring","name":"fromstring","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["string","dtype","count","sep","like"],"arg_types":[{".class":"UnionType","items":["builtins.str","builtins.bytes"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"typing.SupportsIndex","builtins.str",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromstring","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["string","dtype","count","sep","like"],"arg_types":[{".class":"UnionType","items":["builtins.str","builtins.bytes"],"uses_pep604_syntax":true},{".class":"NoneType"},"typing.SupportsIndex","builtins.str",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromstring","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,3,5],"arg_names":["string","dtype","count","sep","like"],"arg_types":[{".class":"UnionType","items":["builtins.str","builtins.bytes"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex","builtins.str",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromstring","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.multiarray.fromstring#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["string","dtype","count","sep","like"],"arg_types":[{".class":"UnionType","items":["builtins.str","builtins.bytes"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"typing.SupportsIndex","builtins.str",{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromstring","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"generic":{".class":"SymbolTableNode","cross_ref":"numpy.generic","kind":"Gdef","module_hidden":true,"module_public":false},"get_handler_name":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.get_handler_name","name":"get_handler_name","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[1],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_handler_name","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_handler_version":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.get_handler_version","name":"get_handler_version","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[1],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_handler_version","ret_type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"inner":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.inner","name":"inner","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"inner","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"int_":{".class":"SymbolTableNode","cross_ref":"numpy.int_","kind":"Gdef","module_hidden":true,"module_public":false},"interp":{".class":"SymbolTableNode","cross_ref":"numpy.lib._function_base_impl.interp","kind":"Gdef"},"interp_complex":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy._core.multiarray.interp_complex","name":"interp_complex","setter_type":null,"type":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":"builtins.object","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"intp":{".class":"SymbolTableNode","cross_ref":"numpy.intp","kind":"Gdef","module_hidden":true,"module_public":false},"is_busday":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.is_busday","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["dates","weekmask","holidays","busdaycal","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.is_busday","name":"is_busday","original_first_arg":"dates","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["dates","weekmask","holidays","busdaycal","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"datetime.date"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy.busdaycalendar",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_busday","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.is_busday","name":"is_busday","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["dates","weekmask","holidays","busdaycal","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"datetime.date"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy.busdaycalendar",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_busday","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["dates","weekmask","holidays","busdaycal","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.is_busday","name":"is_busday","original_first_arg":"dates","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["dates","weekmask","holidays","busdaycal","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy.busdaycalendar",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_busday","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.is_busday","name":"is_busday","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["dates","weekmask","holidays","busdaycal","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy.busdaycalendar",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_busday","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["dates","weekmask","holidays","busdaycal","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.is_busday","name":"is_busday","original_first_arg":"dates","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["dates","weekmask","holidays","busdaycal","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy.busdaycalendar",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.is_busday","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_busday","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.is_busday","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.is_busday","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.is_busday","name":"is_busday","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["dates","weekmask","holidays","busdaycal","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy.busdaycalendar",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.is_busday","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_busday","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.is_busday","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.is_busday","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["dates","weekmask","holidays","busdaycal","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"datetime.date"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy.busdaycalendar",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_busday","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["dates","weekmask","holidays","busdaycal","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy.busdaycalendar",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_busday","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["dates","weekmask","holidays","busdaycal","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"datetime.date",{".class":"Instance","args":["datetime.date"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy.busdaycalendar",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.is_busday","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_busday","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.is_busday","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.multiarray.is_busday","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"lexsort":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["keys","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.lexsort","name":"lexsort","original_first_arg":"keys","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["keys","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lexsort","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"matmul":{".class":"SymbolTableNode","cross_ref":"numpy.matmul","kind":"Gdef"},"may_share_memory":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":[null,null,"max_work"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.may_share_memory","name":"may_share_memory","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":[null,null,"max_work"],"arg_types":["builtins.object","builtins.object",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"may_share_memory","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"min_scalar_type":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.min_scalar_type","name":"min_scalar_type","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"min_scalar_type","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"ndarray":{".class":"SymbolTableNode","cross_ref":"numpy.ndarray","kind":"Gdef"},"nditer":{".class":"SymbolTableNode","cross_ref":"numpy.nditer","kind":"Gdef"},"nested_iters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,1],"arg_names":["op","axes","flags","op_flags","op_dtypes","order","casting","buffersize"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.nested_iters","name":"nested_iters","original_first_arg":"op","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1],"arg_names":["op","axes","flags","op_flags","op_dtypes","order","casting","buffersize"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"Instance","args":[{".class":"Instance","args":["typing.SupportsIndex"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nested_iters","ret_type":{".class":"Instance","args":["numpy.nditer"],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"normalize_axis_index":{".class":"SymbolTableNode","cross_ref":"numpy.lib._array_utils_impl.normalize_axis_index","kind":"Gdef"},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false},"packbits":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":[null,"axis","bitorder"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.packbits","name":"packbits","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":[null,"axis","bitorder"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"big"},{".class":"LiteralType","fallback":"builtins.str","value":"little"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"packbits","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"promote_types":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.promote_types","name":"promote_types","original_first_arg":"__type1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"promote_types","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"putmask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":[null,"mask","values"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.putmask","name":"putmask","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"mask","values"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"putmask","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"ravel_multi_index":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.ravel_multi_index","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["multi_index","dims","mode","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.ravel_multi_index","name":"ravel_multi_index","original_first_arg":"multi_index","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["multi_index","dims","mode","order"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"_typeshed.SupportsLenAndGetItem"},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ravel_multi_index","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.ravel_multi_index","name":"ravel_multi_index","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["multi_index","dims","mode","order"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"_typeshed.SupportsLenAndGetItem"},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ravel_multi_index","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["multi_index","dims","mode","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.ravel_multi_index","name":"ravel_multi_index","original_first_arg":"multi_index","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["multi_index","dims","mode","order"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"_typeshed.SupportsLenAndGetItem"},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ravel_multi_index","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.ravel_multi_index","name":"ravel_multi_index","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["multi_index","dims","mode","order"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"_typeshed.SupportsLenAndGetItem"},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ravel_multi_index","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["multi_index","dims","mode","order"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"_typeshed.SupportsLenAndGetItem"},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ravel_multi_index","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["multi_index","dims","mode","order"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"_typeshed.SupportsLenAndGetItem"},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ravel_multi_index","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"result_type":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[2],"arg_names":["arrays_and_dtypes"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.result_type","name":"result_type","original_first_arg":"arrays_and_dtypes","type":{".class":"CallableType","arg_kinds":[2],"arg_names":["arrays_and_dtypes"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"result_type","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"scalar":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["dtype","object"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.scalar","name":"scalar","original_first_arg":"dtype","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["dtype","object"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.multiarray.scalar","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bytes","builtins.object"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"scalar","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.multiarray.scalar","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.multiarray._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.multiarray.scalar","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}]}}},"set_datetimeparse_function":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy._core.multiarray.set_datetimeparse_function","name":"set_datetimeparse_function","setter_type":null,"type":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":"builtins.object","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"set_typeDict":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.set_typeDict","name":"set_typeDict","original_first_arg":"dict_","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"set_typeDict","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"shares_memory":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":[null,null,"max_work"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.shares_memory","name":"shares_memory","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":[null,null,"max_work"],"arg_types":["builtins.object","builtins.object",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shares_memory","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"signedinteger":{".class":"SymbolTableNode","cross_ref":"numpy.signedinteger","kind":"Gdef","module_hidden":true,"module_public":false},"str_":{".class":"SymbolTableNode","cross_ref":"numpy.str_","kind":"Gdef","module_hidden":true,"module_public":false},"timedelta64":{".class":"SymbolTableNode","cross_ref":"numpy.timedelta64","kind":"Gdef","module_hidden":true,"module_public":false},"tracemalloc_domain":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.multiarray.tracemalloc_domain","name":"tracemalloc_domain","setter_type":null,"type":{".class":"LiteralType","fallback":"builtins.int","value":389047}}},"type_check_only":{".class":"SymbolTableNode","cross_ref":"typing.type_check_only","kind":"Gdef","module_hidden":true,"module_public":false},"typeinfo":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy._core.multiarray.typeinfo","name":"typeinfo","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"ufunc":{".class":"SymbolTableNode","cross_ref":"numpy.ufunc","kind":"Gdef","module_hidden":true,"module_public":false},"uint8":{".class":"SymbolTableNode","cross_ref":"numpy.uint8","kind":"Gdef","module_hidden":true,"module_public":false},"unpackbits":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":[null,"axis","count","bitorder"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.unpackbits","name":"unpackbits","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":[null,"axis","count","bitorder"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"big"},{".class":"LiteralType","fallback":"builtins.str","value":"little"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unpackbits","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"unravel_index":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.unravel_index","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["indices","shape","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.unravel_index","name":"unravel_index","original_first_arg":"indices","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["indices","shape","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unravel_index","ret_type":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.unravel_index","name":"unravel_index","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["indices","shape","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unravel_index","ret_type":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["indices","shape","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.unravel_index","name":"unravel_index","original_first_arg":"indices","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["indices","shape","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unravel_index","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.unravel_index","name":"unravel_index","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["indices","shape","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unravel_index","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["indices","shape","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unravel_index","ret_type":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["indices","shape","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unravel_index","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"unsignedinteger":{".class":"SymbolTableNode","cross_ref":"numpy.unsignedinteger","kind":"Gdef","module_hidden":true,"module_public":false},"vdot":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.vdot","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.vdot","name":"vdot","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vdot","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.vdot","name":"vdot","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vdot","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.vdot","name":"vdot","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vdot","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.unsignedinteger"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.vdot","name":"vdot","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vdot","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.unsignedinteger"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.vdot","name":"vdot","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vdot","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.signedinteger"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.vdot","name":"vdot","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vdot","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.signedinteger"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.vdot","name":"vdot","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vdot","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.vdot","name":"vdot","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vdot","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.vdot","name":"vdot","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vdot","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.vdot","name":"vdot","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vdot","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.vdot","name":"vdot","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vdot","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.vdot","name":"vdot","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vdot","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.vdot","name":"vdot","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vdot","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.vdot","name":"vdot","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vdot","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.vdot","name":"vdot","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vdot","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.vdot","name":"vdot","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vdot","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vdot","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vdot","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.unsignedinteger"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vdot","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.signedinteger"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vdot","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vdot","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vdot","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vdot","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vdot","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"vecdot":{".class":"SymbolTableNode","cross_ref":"numpy.vecdot","kind":"Gdef"},"where":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.multiarray.where","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.where","name":"where","original_first_arg":"condition","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"where","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.where","name":"where","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"where","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":[null,null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.multiarray.where","name":"where","original_first_arg":"condition","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"where","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.multiarray.where","name":"where","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"where","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"where","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"where","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"zeros":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy._core.multiarray.zeros","name":"zeros","setter_type":null,"type":"numpy._core.multiarray._ConstructorEmpty"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_core/multiarray.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/multiarray.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/multiarray.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..a7466e636931a53c9d6b095b78602f3522685a43 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/multiarray.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[97,104,3,68,2,4,22,23,25,1,1,1,1,1,1,1,1,1],"dep_prios":[5,5,5,5,10,5,5,5,5,5,30,30,30,30,30,30,30,30],"dependencies":["numpy._typing._ufunc","numpy.lib._array_utils_impl","collections.abc","numpy._typing","datetime","typing","_typeshed","typing_extensions","numpy","builtins","_frozen_importlib","abc","enum","numpy._globals","numpy._typing._array_like","numpy._typing._dtype_like","numpy._typing._nested_sequence","os"],"hash":"6ca33a3d0ba4bf6767622708dc5e4ad3af266b54","id":"numpy._core.multiarray","ignore_all":true,"interface_hash":"a74f41461adf2bce360973f6f1dd04a0f26b38c1","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_core/multiarray.pyi","plugin_data":null,"size":32150,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/numeric.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/numeric.data.json new file mode 100644 index 0000000000000000000000000000000000000000..7f8d4da6616fae89b856ea93e7a6f0348fce61ba --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/numeric.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy._core.numeric","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef","module_hidden":true,"module_public":false},"DTypeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like.DTypeLike","kind":"Gdef","module_hidden":true,"module_public":false},"False_":{".class":"SymbolTableNode","cross_ref":"numpy.False_","kind":"Gdef"},"Final":{".class":"SymbolTableNode","cross_ref":"typing.Final","kind":"Gdef","module_hidden":true,"module_public":false},"L":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"Never":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy._core.numeric.Never","name":"Never","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.numeric.Never","source_any":null,"type_of_any":3}}},"NoReturn":{".class":"SymbolTableNode","cross_ref":"typing.NoReturn","kind":"Gdef","module_hidden":true,"module_public":false},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef","module_hidden":true,"module_public":false},"SupportsAbs":{".class":"SymbolTableNode","cross_ref":"typing.SupportsAbs","kind":"Gdef","module_hidden":true,"module_public":false},"SupportsIndex":{".class":"SymbolTableNode","cross_ref":"typing.SupportsIndex","kind":"Gdef","module_hidden":true,"module_public":false},"True_":{".class":"SymbolTableNode","cross_ref":"numpy.True_","kind":"Gdef"},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy._core.numeric.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}}},"TypeGuard":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy._core.numeric.TypeGuard","name":"TypeGuard","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeGuard","source_any":null,"type_of_any":3}}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"Unpack":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy._core.numeric.Unpack","name":"Unpack","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}}},"_AnyShapeT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._AnyShapeT","name":"_AnyShapeT","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0}},"_Array":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray._Array","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeBool_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeBool_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeComplex_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeComplex_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeFloat_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeFloat_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeInt_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeInt_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeObject_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeObject_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeTD64_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeTD64_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeUInt_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeUInt_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","name":"_ArrayT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}},"_ConstructorEmpty":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray._ConstructorEmpty","kind":"Gdef","module_hidden":true,"module_public":false},"_CorrelateMode":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._core.numeric._CorrelateMode","name":"_CorrelateMode","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}}},"_DTypeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._DTypeLike","kind":"Gdef","module_hidden":true,"module_public":false},"_DTypeT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","name":"_DTypeT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}},"_KwargsEmpty":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray._KwargsEmpty","kind":"Gdef","module_hidden":true,"module_public":false},"_NestedSequence":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nested_sequence._NestedSequence","kind":"Gdef","module_hidden":true,"module_public":false},"_OrderCF":{".class":"SymbolTableNode","cross_ref":"numpy._OrderCF","kind":"Gdef","module_hidden":true,"module_public":false},"_OrderKACF":{".class":"SymbolTableNode","cross_ref":"numpy._OrderKACF","kind":"Gdef","module_hidden":true,"module_public":false},"_ScalarLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._ScalarLike_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ScalarT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","name":"_ScalarT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},"_Shape":{".class":"SymbolTableNode","cross_ref":"numpy._typing._shape._Shape","kind":"Gdef","module_hidden":true,"module_public":false},"_ShapeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._shape._ShapeLike","kind":"Gdef","module_hidden":true,"module_public":false},"_ShapeT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ShapeT","name":"_ShapeT","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}},"_SupportsArrayFunc":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._SupportsArrayFunc","kind":"Gdef","module_hidden":true,"module_public":false},"_SupportsDType":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._SupportsDType","kind":"Gdef","module_hidden":true,"module_public":false},"_T":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._T","name":"_T","upper_bound":"builtins.object","values":[],"variance":0}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy._core.numeric.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.numeric.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.numeric.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.numeric.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.numeric.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.numeric.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.numeric.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"all":{".class":"SymbolTableNode","cross_ref":"numpy._core.fromnumeric.all","kind":"Gdef","module_public":false},"allclose":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["a","b","rtol","atol","equal_nan"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.numeric.allclose","name":"allclose","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","b","rtol","atol","equal_nan"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"allclose","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"any":{".class":"SymbolTableNode","cross_ref":"numpy._core.fromnumeric.any","kind":"Gdef","module_public":false},"arange":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.arange","kind":"Gdef"},"argpartition":{".class":"SymbolTableNode","cross_ref":"numpy._core.fromnumeric.argpartition","kind":"Gdef","module_public":false},"argwhere":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.numeric.argwhere","name":"argwhere","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argwhere","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"array":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.array","kind":"Gdef"},"array_equal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a1","a2","equal_nan"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.numeric.array_equal","name":"array_equal","original_first_arg":"a1","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a1","a2","equal_nan"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array_equal","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"array_equiv":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a1","a2"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.numeric.array_equiv","name":"array_equiv","original_first_arg":"a1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array_equiv","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"asanyarray":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.asanyarray","kind":"Gdef"},"asarray":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.asarray","kind":"Gdef"},"ascontiguousarray":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.ascontiguousarray","kind":"Gdef"},"asfortranarray":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.asfortranarray","kind":"Gdef"},"astype":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.numeric.astype","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5],"arg_names":[null,null,"copy","device"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.astype","name":"astype","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,5,5],"arg_names":[null,null,"copy","device"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ShapeT","id":-1,"name":"_ShapeT","namespace":"numpy._core.numeric.astype#0","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"astype","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ShapeT","id":-1,"name":"_ShapeT","namespace":"numpy._core.numeric.astype#0","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-2,"name":"_ScalarT","namespace":"numpy._core.numeric.astype#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ShapeT","id":-1,"name":"_ShapeT","namespace":"numpy._core.numeric.astype#0","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-2,"name":"_ScalarT","namespace":"numpy._core.numeric.astype#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.astype","name":"astype","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5,5],"arg_names":[null,null,"copy","device"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ShapeT","id":-1,"name":"_ShapeT","namespace":"numpy._core.numeric.astype#0","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"astype","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ShapeT","id":-1,"name":"_ShapeT","namespace":"numpy._core.numeric.astype#0","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-2,"name":"_ScalarT","namespace":"numpy._core.numeric.astype#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ShapeT","id":-1,"name":"_ShapeT","namespace":"numpy._core.numeric.astype#0","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-2,"name":"_ScalarT","namespace":"numpy._core.numeric.astype#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5],"arg_names":[null,null,"copy","device"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.astype","name":"astype","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,5,5],"arg_names":[null,null,"copy","device"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ShapeT","id":-1,"name":"_ShapeT","namespace":"numpy._core.numeric.astype","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"astype","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ShapeT","id":-1,"name":"_ShapeT","namespace":"numpy._core.numeric.astype","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ShapeT","id":-1,"name":"_ShapeT","namespace":"numpy._core.numeric.astype","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.astype","name":"astype","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5,5],"arg_names":[null,null,"copy","device"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ShapeT","id":-1,"name":"_ShapeT","namespace":"numpy._core.numeric.astype","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"astype","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ShapeT","id":-1,"name":"_ShapeT","namespace":"numpy._core.numeric.astype","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ShapeT","id":-1,"name":"_ShapeT","namespace":"numpy._core.numeric.astype","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,5,5],"arg_names":[null,null,"copy","device"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ShapeT","id":-1,"name":"_ShapeT","namespace":"numpy._core.numeric.astype#0","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"astype","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ShapeT","id":-1,"name":"_ShapeT","namespace":"numpy._core.numeric.astype#0","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-2,"name":"_ScalarT","namespace":"numpy._core.numeric.astype#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ShapeT","id":-1,"name":"_ShapeT","namespace":"numpy._core.numeric.astype#0","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-2,"name":"_ScalarT","namespace":"numpy._core.numeric.astype#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,5,5],"arg_names":[null,null,"copy","device"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ShapeT","id":-1,"name":"_ShapeT","namespace":"numpy._core.numeric.astype","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"astype","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ShapeT","id":-1,"name":"_ShapeT","namespace":"numpy._core.numeric.astype","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ShapeT","id":-1,"name":"_ShapeT","namespace":"numpy._core.numeric.astype","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}]}}},"base_repr":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["number","base","padding"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.numeric.base_repr","name":"base_repr","original_first_arg":"number","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["number","base","padding"],"arg_types":[{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"typing.SupportsAbs"},"builtins.float",{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"base_repr","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"binary_repr":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["num","width"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.numeric.binary_repr","name":"binary_repr","original_first_arg":"num","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["num","width"],"arg_types":["typing.SupportsIndex",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"binary_repr","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"bitwise_not":{".class":"SymbolTableNode","cross_ref":"numpy.bitwise_not","kind":"Gdef"},"broadcast":{".class":"SymbolTableNode","cross_ref":"numpy.broadcast","kind":"Gdef"},"can_cast":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.can_cast","kind":"Gdef"},"complexfloating":{".class":"SymbolTableNode","cross_ref":"numpy.complexfloating","kind":"Gdef","module_hidden":true,"module_public":false},"concatenate":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.concatenate","kind":"Gdef"},"convolve":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.numeric.convolve","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.convolve","name":"convolve","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"convolve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.convolve","name":"convolve","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"convolve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.convolve","name":"convolve","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"convolve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.convolve","name":"convolve","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"convolve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.convolve","name":"convolve","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"convolve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.convolve","name":"convolve","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"convolve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.convolve","name":"convolve","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"convolve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.convolve","name":"convolve","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"convolve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.convolve","name":"convolve","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"convolve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.convolve","name":"convolve","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"convolve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.convolve","name":"convolve","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"convolve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.convolve","name":"convolve","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"convolve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.convolve","name":"convolve","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"convolve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.convolve","name":"convolve","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"convolve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.convolve","name":"convolve","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"convolve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.convolve","name":"convolve","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"convolve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"convolve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"convolve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"convolve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"convolve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"convolve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"convolve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"convolve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"convolve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"copyto":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.copyto","kind":"Gdef"},"correlate":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.numeric.correlate","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.correlate","name":"correlate","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"correlate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.correlate","name":"correlate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"correlate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.correlate","name":"correlate","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"correlate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.correlate","name":"correlate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"correlate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.correlate","name":"correlate","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"correlate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.correlate","name":"correlate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"correlate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.correlate","name":"correlate","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"correlate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.correlate","name":"correlate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"correlate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.correlate","name":"correlate","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"correlate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.correlate","name":"correlate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"correlate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.correlate","name":"correlate","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"correlate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.correlate","name":"correlate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"correlate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.correlate","name":"correlate","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"correlate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.correlate","name":"correlate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"correlate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.correlate","name":"correlate","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"correlate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.correlate","name":"correlate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"correlate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"correlate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"correlate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"correlate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"correlate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"correlate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"correlate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"correlate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","v","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"correlate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"count_nonzero":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.numeric.count_nonzero","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,5],"arg_names":["a","axis","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.count_nonzero","name":"count_nonzero","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,5],"arg_names":["a","axis","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count_nonzero","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.count_nonzero","name":"count_nonzero","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,5],"arg_names":["a","axis","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count_nonzero","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3],"arg_names":["a","axis","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.count_nonzero","name":"count_nonzero","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,3],"arg_names":["a","axis","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count_nonzero","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.count_nonzero","name":"count_nonzero","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3],"arg_names":["a","axis","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count_nonzero","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3],"arg_names":["a","axis","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.count_nonzero","name":"count_nonzero","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,3],"arg_names":["a","axis","keepdims"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count_nonzero","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.count_nonzero","name":"count_nonzero","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3],"arg_names":["a","axis","keepdims"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count_nonzero","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,5],"arg_names":["a","axis","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.count_nonzero","name":"count_nonzero","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,5],"arg_names":["a","axis","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count_nonzero","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.count_nonzero","name":"count_nonzero","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,5],"arg_names":["a","axis","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count_nonzero","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,5],"arg_names":["a","axis","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count_nonzero","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,3],"arg_names":["a","axis","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count_nonzero","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,3],"arg_names":["a","axis","keepdims"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count_nonzero","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,5],"arg_names":["a","axis","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count_nonzero","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"cross":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.numeric.cross","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1],"arg_names":["a","b","axisa","axisb","axisc","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.cross","name":"cross","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["a","b","axisa","axisb","axisc","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int","builtins.int","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cross","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.cross","name":"cross","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["a","b","axisa","axisb","axisc","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int","builtins.int","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cross","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1],"arg_names":["a","b","axisa","axisb","axisc","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.cross","name":"cross","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["a","b","axisa","axisb","axisc","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int","builtins.int","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cross","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.cross","name":"cross","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["a","b","axisa","axisb","axisc","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int","builtins.int","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cross","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1],"arg_names":["a","b","axisa","axisb","axisc","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.cross","name":"cross","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["a","b","axisa","axisb","axisc","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int","builtins.int","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cross","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.cross","name":"cross","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["a","b","axisa","axisb","axisc","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int","builtins.int","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cross","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1],"arg_names":["a","b","axisa","axisb","axisc","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.cross","name":"cross","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["a","b","axisa","axisb","axisc","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int","builtins.int","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cross","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.cross","name":"cross","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["a","b","axisa","axisb","axisc","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int","builtins.int","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cross","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1],"arg_names":["a","b","axisa","axisb","axisc","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.cross","name":"cross","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["a","b","axisa","axisb","axisc","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int","builtins.int","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cross","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.cross","name":"cross","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["a","b","axisa","axisb","axisc","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int","builtins.int","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cross","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1],"arg_names":["a","b","axisa","axisb","axisc","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.cross","name":"cross","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["a","b","axisa","axisb","axisc","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int","builtins.int","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cross","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.cross","name":"cross","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["a","b","axisa","axisb","axisc","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int","builtins.int","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cross","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1],"arg_names":["a","b","axisa","axisb","axisc","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.cross","name":"cross","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["a","b","axisa","axisb","axisc","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int","builtins.int","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cross","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.cross","name":"cross","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["a","b","axisa","axisb","axisc","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int","builtins.int","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cross","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["a","b","axisa","axisb","axisc","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int","builtins.int","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cross","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["a","b","axisa","axisb","axisc","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int","builtins.int","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cross","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["a","b","axisa","axisb","axisc","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int","builtins.int","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cross","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["a","b","axisa","axisb","axisc","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int","builtins.int","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cross","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["a","b","axisa","axisb","axisc","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int","builtins.int","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cross","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["a","b","axisa","axisb","axisc","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int","builtins.int","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cross","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["a","b","axisa","axisb","axisc","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int","builtins.int","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cross","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"dot":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.dot","kind":"Gdef"},"dtype":{".class":"SymbolTableNode","cross_ref":"numpy.dtype","kind":"Gdef"},"empty":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.empty","kind":"Gdef"},"empty_like":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.empty_like","kind":"Gdef"},"flatiter":{".class":"SymbolTableNode","cross_ref":"numpy.flatiter","kind":"Gdef"},"flatnonzero":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.numeric.flatnonzero","name":"flatnonzero","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"flatnonzero","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"float64":{".class":"SymbolTableNode","cross_ref":"numpy.float64","kind":"Gdef","module_hidden":true,"module_public":false},"floating":{".class":"SymbolTableNode","cross_ref":"numpy.floating","kind":"Gdef","module_hidden":true,"module_public":false},"from_dlpack":{".class":"SymbolTableNode","cross_ref":"numpy.from_dlpack","kind":"Gdef"},"frombuffer":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.frombuffer","kind":"Gdef"},"fromfile":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.fromfile","kind":"Gdef"},"fromfunction":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,4],"arg_names":["function","shape","dtype","like","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.numeric.fromfunction","name":"fromfunction","original_first_arg":"function","type":{".class":"CallableType","arg_kinds":[0,0,5,5,4],"arg_names":["function","shape","dtype","like","kwargs"],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._T","id":-1,"name":"_T","namespace":"numpy._core.numeric.fromfunction","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromfunction","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._T","id":-1,"name":"_T","namespace":"numpy._core.numeric.fromfunction","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._T","id":-1,"name":"_T","namespace":"numpy._core.numeric.fromfunction","upper_bound":"builtins.object","values":[],"variance":0}]}}},"fromiter":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.fromiter","kind":"Gdef"},"fromstring":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.fromstring","kind":"Gdef"},"full":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.numeric.full","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.full","name":"full","original_first_arg":"shape","type":{".class":"CallableType","arg_kinds":[0,0,1,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"arg_types":["typing.SupportsIndex",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.full#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.full#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.full","name":"full","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"arg_types":["typing.SupportsIndex",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.full#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.full#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.full","name":"full","original_first_arg":"shape","type":{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"arg_types":["typing.SupportsIndex",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.numeric.full#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.numeric.full#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.numeric.full#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.numeric.full#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.full","name":"full","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"arg_types":["typing.SupportsIndex",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.numeric.full#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.numeric.full#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.numeric.full#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.numeric.full#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.full","name":"full","original_first_arg":"shape","type":{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"arg_types":["typing.SupportsIndex",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.full#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.full#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.full","name":"full","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"arg_types":["typing.SupportsIndex",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.full#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.full#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.full","name":"full","original_first_arg":"shape","type":{".class":"CallableType","arg_kinds":[0,0,1,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"arg_types":["typing.SupportsIndex",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.full","name":"full","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"arg_types":["typing.SupportsIndex",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.full","name":"full","original_first_arg":"shape","type":{".class":"CallableType","arg_kinds":[0,0,1,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.numeric.full#4","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-2,"name":"_ScalarT","namespace":"numpy._core.numeric.full#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.numeric.full#4","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-2,"name":"_ScalarT","namespace":"numpy._core.numeric.full#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.full","name":"full","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.numeric.full#4","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-2,"name":"_ScalarT","namespace":"numpy._core.numeric.full#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.numeric.full#4","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-2,"name":"_ScalarT","namespace":"numpy._core.numeric.full#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.full","name":"full","original_first_arg":"shape","type":{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.numeric.full#5","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","id":-2,"name":"_DTypeT","namespace":"numpy._core.numeric.full#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","id":-2,"name":"_DTypeT","namespace":"numpy._core.numeric.full#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.numeric.full#5","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","id":-2,"name":"_DTypeT","namespace":"numpy._core.numeric.full#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.numeric.full#5","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","id":-2,"name":"_DTypeT","namespace":"numpy._core.numeric.full#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.full","name":"full","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.numeric.full#5","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","id":-2,"name":"_DTypeT","namespace":"numpy._core.numeric.full#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","id":-2,"name":"_DTypeT","namespace":"numpy._core.numeric.full#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.numeric.full#5","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","id":-2,"name":"_DTypeT","namespace":"numpy._core.numeric.full#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.numeric.full#5","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","id":-2,"name":"_DTypeT","namespace":"numpy._core.numeric.full#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.full","name":"full","original_first_arg":"shape","type":{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.numeric.full#6","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-2,"name":"_ScalarT","namespace":"numpy._core.numeric.full#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.numeric.full#6","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-2,"name":"_ScalarT","namespace":"numpy._core.numeric.full#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.full","name":"full","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.numeric.full#6","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-2,"name":"_ScalarT","namespace":"numpy._core.numeric.full#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.numeric.full#6","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-2,"name":"_ScalarT","namespace":"numpy._core.numeric.full#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.full","name":"full","original_first_arg":"shape","type":{".class":"CallableType","arg_kinds":[0,0,1,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.numeric.full#7","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.numeric.full#7","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.full","name":"full","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.numeric.full#7","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.numeric.full#7","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.full","name":"full","original_first_arg":"shape","type":{".class":"CallableType","arg_kinds":[0,0,1,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.full#8","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.full#8","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.full","name":"full","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.full#8","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.full#8","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.full","name":"full","original_first_arg":"shape","type":{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.numeric.full#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.numeric.full#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.numeric.full#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.numeric.full#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.full","name":"full","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.numeric.full#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.numeric.full#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.numeric.full#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.numeric.full#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.full","name":"full","original_first_arg":"shape","type":{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.full#10","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.full#10","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.full","name":"full","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.full#10","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.full#10","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.full","name":"full","original_first_arg":"shape","type":{".class":"CallableType","arg_kinds":[0,0,1,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.full","name":"full","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"arg_types":["typing.SupportsIndex",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.full#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.full#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"arg_types":["typing.SupportsIndex",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.numeric.full#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.numeric.full#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.numeric.full#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.numeric.full#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"arg_types":["typing.SupportsIndex",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.full#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.full#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"arg_types":["typing.SupportsIndex",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.numeric.full#4","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-2,"name":"_ScalarT","namespace":"numpy._core.numeric.full#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.numeric.full#4","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-2,"name":"_ScalarT","namespace":"numpy._core.numeric.full#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.numeric.full#5","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","id":-2,"name":"_DTypeT","namespace":"numpy._core.numeric.full#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","id":-2,"name":"_DTypeT","namespace":"numpy._core.numeric.full#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.numeric.full#5","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","id":-2,"name":"_DTypeT","namespace":"numpy._core.numeric.full#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.numeric.full#5","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","id":-2,"name":"_DTypeT","namespace":"numpy._core.numeric.full#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.numeric.full#6","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-2,"name":"_ScalarT","namespace":"numpy._core.numeric.full#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.numeric.full#6","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-2,"name":"_ScalarT","namespace":"numpy._core.numeric.full#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.numeric.full#7","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.multiarray.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._AnyShapeT","id":-1,"name":"_AnyShapeT","namespace":"numpy._core.numeric.full#7","upper_bound":"builtins.object","values":[{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.full#8","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.full#8","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.numeric.full#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.numeric.full#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.numeric.full#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy._core.numeric.full#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.full#10","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.full#10","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,4],"arg_names":["shape","fill_value","dtype","order","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.numeric.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"full_like":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.numeric.full_like","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,5],"arg_names":["a","fill_value","dtype","order","subok","shape","device"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.full_like","name":"full_like","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,5],"arg_names":["a","fill_value","dtype","order","subok","shape","device"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.numeric.full_like#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full_like","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.numeric.full_like#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.numeric.full_like#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.full_like","name":"full_like","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,5],"arg_names":["a","fill_value","dtype","order","subok","shape","device"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.numeric.full_like#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full_like","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.numeric.full_like#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.numeric.full_like#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,5],"arg_names":["a","fill_value","dtype","order","subok","shape","device"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.full_like","name":"full_like","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,5],"arg_names":["a","fill_value","dtype","order","subok","shape","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full_like","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.full_like#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.full_like","name":"full_like","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,5],"arg_names":["a","fill_value","dtype","order","subok","shape","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full_like","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.full_like#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1,5],"arg_names":["a","fill_value","dtype","order","subok","shape","device"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.full_like","name":"full_like","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,5],"arg_names":["a","fill_value","dtype","order","subok","shape","device"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full_like","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.full_like#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.full_like","name":"full_like","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,5],"arg_names":["a","fill_value","dtype","order","subok","shape","device"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full_like","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.full_like#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,5],"arg_names":["a","fill_value","dtype","order","subok","shape","device"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.full_like","name":"full_like","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,5],"arg_names":["a","fill_value","dtype","order","subok","shape","device"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full_like","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.full_like","name":"full_like","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,5],"arg_names":["a","fill_value","dtype","order","subok","shape","device"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full_like","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,5],"arg_names":["a","fill_value","dtype","order","subok","shape","device"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.numeric.full_like#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full_like","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.numeric.full_like#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.numeric.full_like#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,5],"arg_names":["a","fill_value","dtype","order","subok","shape","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full_like","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.full_like#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,5],"arg_names":["a","fill_value","dtype","order","subok","shape","device"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full_like","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.full_like#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,5],"arg_names":["a","fill_value","dtype","order","subok","shape","device"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"full_like","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"generic":{".class":"SymbolTableNode","cross_ref":"numpy.generic","kind":"Gdef","module_hidden":true,"module_public":false},"identity":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.numeric.identity","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,5],"arg_names":["n","dtype","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.identity","name":"identity","original_first_arg":"n","type":{".class":"CallableType","arg_kinds":[0,1,5],"arg_names":["n","dtype","like"],"arg_types":["builtins.int",{".class":"NoneType"},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"identity","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.identity","name":"identity","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,5],"arg_names":["n","dtype","like"],"arg_types":["builtins.int",{".class":"NoneType"},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"identity","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5],"arg_names":["n","dtype","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.identity","name":"identity","original_first_arg":"n","type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["n","dtype","like"],"arg_types":["builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"identity","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.identity#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.identity","name":"identity","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["n","dtype","like"],"arg_types":["builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"identity","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.identity#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,5],"arg_names":["n","dtype","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.identity","name":"identity","original_first_arg":"n","type":{".class":"CallableType","arg_kinds":[0,1,5],"arg_names":["n","dtype","like"],"arg_types":["builtins.int",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"identity","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.identity","name":"identity","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,5],"arg_names":["n","dtype","like"],"arg_types":["builtins.int",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"identity","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,5],"arg_names":["n","dtype","like"],"arg_types":["builtins.int",{".class":"NoneType"},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"identity","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["n","dtype","like"],"arg_types":["builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"identity","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.identity#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,5],"arg_names":["n","dtype","like"],"arg_types":["builtins.int",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"identity","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"indices":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.numeric.indices","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["dimensions","dtype","sparse"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.indices","name":"indices","original_first_arg":"dimensions","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["dimensions","dtype","sparse"],"arg_types":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"TypeType","item":"builtins.int"},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"indices","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.indices","name":"indices","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["dimensions","dtype","sparse"],"arg_types":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"TypeType","item":"builtins.int"},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"indices","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["dimensions","dtype","sparse"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.indices","name":"indices","original_first_arg":"dimensions","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["dimensions","dtype","sparse"],"arg_types":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"TypeType","item":"builtins.int"},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"indices","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.indices","name":"indices","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["dimensions","dtype","sparse"],"arg_types":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"TypeType","item":"builtins.int"},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"indices","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3],"arg_names":["dimensions","dtype","sparse"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.indices","name":"indices","original_first_arg":"dimensions","type":{".class":"CallableType","arg_kinds":[0,1,3],"arg_names":["dimensions","dtype","sparse"],"arg_types":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"TypeType","item":"builtins.int"},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"indices","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.indices","name":"indices","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3],"arg_names":["dimensions","dtype","sparse"],"arg_types":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"TypeType","item":"builtins.int"},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"indices","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["dimensions","dtype","sparse"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.indices","name":"indices","original_first_arg":"dimensions","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["dimensions","dtype","sparse"],"arg_types":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"indices","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.indices#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.indices","name":"indices","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["dimensions","dtype","sparse"],"arg_types":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"indices","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.indices#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["dimensions","dtype","sparse"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.indices","name":"indices","original_first_arg":"dimensions","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["dimensions","dtype","sparse"],"arg_types":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"indices","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.indices#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.indices","name":"indices","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["dimensions","dtype","sparse"],"arg_types":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"indices","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.indices#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["dimensions","dtype","sparse"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.indices","name":"indices","original_first_arg":"dimensions","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["dimensions","dtype","sparse"],"arg_types":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"indices","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.indices","name":"indices","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["dimensions","dtype","sparse"],"arg_types":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"indices","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["dimensions","dtype","sparse"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.indices","name":"indices","original_first_arg":"dimensions","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["dimensions","dtype","sparse"],"arg_types":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"indices","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.indices","name":"indices","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["dimensions","dtype","sparse"],"arg_types":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"indices","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3],"arg_names":["dimensions","dtype","sparse"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.indices","name":"indices","original_first_arg":"dimensions","type":{".class":"CallableType","arg_kinds":[0,1,3],"arg_names":["dimensions","dtype","sparse"],"arg_types":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"indices","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.indices","name":"indices","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3],"arg_names":["dimensions","dtype","sparse"],"arg_types":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"indices","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["dimensions","dtype","sparse"],"arg_types":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"TypeType","item":"builtins.int"},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"indices","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["dimensions","dtype","sparse"],"arg_types":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"TypeType","item":"builtins.int"},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"indices","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,3],"arg_names":["dimensions","dtype","sparse"],"arg_types":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"TypeType","item":"builtins.int"},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"indices","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["dimensions","dtype","sparse"],"arg_types":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"indices","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.indices#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["dimensions","dtype","sparse"],"arg_types":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"indices","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.indices#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["dimensions","dtype","sparse"],"arg_types":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"indices","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["dimensions","dtype","sparse"],"arg_types":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"indices","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,3],"arg_names":["dimensions","dtype","sparse"],"arg_types":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"indices","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"inf":{".class":"SymbolTableNode","cross_ref":"numpy.inf","kind":"Gdef"},"inner":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.inner","kind":"Gdef"},"int_":{".class":"SymbolTableNode","cross_ref":"numpy.int_","kind":"Gdef","module_hidden":true,"module_public":false},"intp":{".class":"SymbolTableNode","cross_ref":"numpy.intp","kind":"Gdef","module_hidden":true,"module_public":false},"isclose":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.numeric.isclose","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["a","b","rtol","atol","equal_nan"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.isclose","name":"isclose","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","b","rtol","atol","equal_nan"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isclose","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.isclose","name":"isclose","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","b","rtol","atol","equal_nan"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isclose","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["a","b","rtol","atol","equal_nan"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.isclose","name":"isclose","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","b","rtol","atol","equal_nan"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isclose","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.isclose","name":"isclose","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","b","rtol","atol","equal_nan"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isclose","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","b","rtol","atol","equal_nan"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isclose","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","b","rtol","atol","equal_nan"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isclose","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"isfortran":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.numeric.isfortran","name":"isfortran","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isfortran","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isscalar":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["element"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.numeric.isscalar","name":"isscalar","original_first_arg":"element","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["element"],"arg_types":["builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isscalar","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.numeric.TypeGuard","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"lexsort":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.lexsort","kind":"Gdef"},"little_endian":{".class":"SymbolTableNode","cross_ref":"numpy.little_endian","kind":"Gdef"},"matmul":{".class":"SymbolTableNode","cross_ref":"numpy.matmul","kind":"Gdef"},"matrix_transpose":{".class":"SymbolTableNode","cross_ref":"numpy._core.fromnumeric.matrix_transpose","kind":"Gdef","module_public":false},"may_share_memory":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.may_share_memory","kind":"Gdef"},"mean":{".class":"SymbolTableNode","cross_ref":"numpy._core.fromnumeric.mean","kind":"Gdef","module_public":false},"min_scalar_type":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.min_scalar_type","kind":"Gdef"},"moveaxis":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["a","source","destination"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.numeric.moveaxis","name":"moveaxis","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["a","source","destination"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"moveaxis","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.moveaxis","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},"nan":{".class":"SymbolTableNode","cross_ref":"numpy.nan","kind":"Gdef"},"ndarray":{".class":"SymbolTableNode","cross_ref":"numpy.ndarray","kind":"Gdef"},"nditer":{".class":"SymbolTableNode","cross_ref":"numpy.nditer","kind":"Gdef"},"nested_iters":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.nested_iters","kind":"Gdef"},"newaxis":{".class":"SymbolTableNode","cross_ref":"numpy.newaxis","kind":"Gdef"},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"object_":{".class":"SymbolTableNode","cross_ref":"numpy.object_","kind":"Gdef","module_hidden":true,"module_public":false},"ones":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy._core.numeric.ones","name":"ones","setter_type":null,"type":"numpy._core.multiarray._ConstructorEmpty"}},"ones_like":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.numeric.ones_like","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,5],"arg_names":["a","dtype","order","subok","shape","device"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.ones_like","name":"ones_like","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["a","dtype","order","subok","shape","device"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.numeric.ones_like#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ones_like","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.numeric.ones_like#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.numeric.ones_like#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.ones_like","name":"ones_like","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["a","dtype","order","subok","shape","device"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.numeric.ones_like#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ones_like","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.numeric.ones_like#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.numeric.ones_like#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,5],"arg_names":["a","dtype","order","subok","shape","device"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.ones_like","name":"ones_like","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["a","dtype","order","subok","shape","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ones_like","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.ones_like#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.ones_like","name":"ones_like","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["a","dtype","order","subok","shape","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ones_like","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.ones_like#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,5],"arg_names":["a","dtype","order","subok","shape","device"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.ones_like","name":"ones_like","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,5],"arg_names":["a","dtype","order","subok","shape","device"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ones_like","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.ones_like#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.ones_like","name":"ones_like","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,5],"arg_names":["a","dtype","order","subok","shape","device"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ones_like","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.ones_like#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,5],"arg_names":["a","dtype","order","subok","shape","device"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.ones_like","name":"ones_like","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["a","dtype","order","subok","shape","device"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ones_like","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.ones_like","name":"ones_like","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["a","dtype","order","subok","shape","device"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ones_like","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["a","dtype","order","subok","shape","device"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.numeric.ones_like#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ones_like","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.numeric.ones_like#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.numeric.ones_like#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["a","dtype","order","subok","shape","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ones_like","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.ones_like#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,5],"arg_names":["a","dtype","order","subok","shape","device"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ones_like","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.ones_like#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["a","dtype","order","subok","shape","device"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ones_like","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"outer":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.numeric.outer","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","b","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.outer","name":"outer","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.outer","name":"outer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","b","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.outer","name":"outer","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.outer","name":"outer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","b","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.outer","name":"outer","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.outer","name":"outer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","b","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.outer","name":"outer","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.outer","name":"outer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","b","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.outer","name":"outer","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.outer","name":"outer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","b","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.outer","name":"outer","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.outer","name":"outer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","b","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.outer","name":"outer","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.outer","name":"outer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","b","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.outer","name":"outer","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.outer","name":"outer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["a","b","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.outer","name":"outer","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["a","b","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.numeric.outer","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.numeric.outer","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.numeric.outer","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.outer","name":"outer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["a","b","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.numeric.outer","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.numeric.outer","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.numeric.outer","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["a","b","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.numeric.outer","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.numeric.outer","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.numeric.outer","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false},"promote_types":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.promote_types","kind":"Gdef"},"putmask":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.putmask","kind":"Gdef"},"result_type":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.result_type","kind":"Gdef"},"roll":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.numeric.roll","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","shift","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.roll","name":"roll","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","shift","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"roll","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.roll#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.roll","name":"roll","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","shift","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"roll","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.roll#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","shift","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.roll","name":"roll","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","shift","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"roll","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.roll","name":"roll","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","shift","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"roll","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","shift","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"roll","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.roll#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","shift","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"roll","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"rollaxis":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","axis","start"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.numeric.rollaxis","name":"rollaxis","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","axis","start"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rollaxis","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.rollaxis","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},"shares_memory":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.shares_memory","kind":"Gdef"},"signedinteger":{".class":"SymbolTableNode","cross_ref":"numpy.signedinteger","kind":"Gdef","module_hidden":true,"module_public":false},"tensordot":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.numeric.tensordot","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.tensordot","name":"tensordot","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensordot","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.tensordot","name":"tensordot","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensordot","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.tensordot","name":"tensordot","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensordot","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.tensordot","name":"tensordot","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensordot","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.tensordot","name":"tensordot","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensordot","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.tensordot","name":"tensordot","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensordot","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.tensordot","name":"tensordot","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensordot","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.tensordot","name":"tensordot","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensordot","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.tensordot","name":"tensordot","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensordot","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.tensordot","name":"tensordot","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensordot","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.tensordot","name":"tensordot","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensordot","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.tensordot","name":"tensordot","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensordot","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.tensordot","name":"tensordot","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensordot","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.tensordot","name":"tensordot","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensordot","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.tensordot","name":"tensordot","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensordot","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.tensordot","name":"tensordot","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensordot","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensordot","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensordot","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensordot","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensordot","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensordot","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensordot","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensordot","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensordot","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"timedelta64":{".class":"SymbolTableNode","cross_ref":"numpy.timedelta64","kind":"Gdef","module_hidden":true,"module_public":false},"ufunc":{".class":"SymbolTableNode","cross_ref":"numpy.ufunc","kind":"Gdef"},"unsignedinteger":{".class":"SymbolTableNode","cross_ref":"numpy.unsignedinteger","kind":"Gdef","module_hidden":true,"module_public":false},"vdot":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.vdot","kind":"Gdef"},"vecdot":{".class":"SymbolTableNode","cross_ref":"numpy.vecdot","kind":"Gdef"},"where":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.where","kind":"Gdef"},"zeros":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.zeros","kind":"Gdef"},"zeros_like":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.numeric.zeros_like","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,5],"arg_names":["a","dtype","order","subok","shape","device"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.zeros_like","name":"zeros_like","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["a","dtype","order","subok","shape","device"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.numeric.zeros_like#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zeros_like","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.numeric.zeros_like#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.numeric.zeros_like#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.zeros_like","name":"zeros_like","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["a","dtype","order","subok","shape","device"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.numeric.zeros_like#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zeros_like","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.numeric.zeros_like#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.numeric.zeros_like#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,5],"arg_names":["a","dtype","order","subok","shape","device"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.zeros_like","name":"zeros_like","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["a","dtype","order","subok","shape","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zeros_like","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.zeros_like#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.zeros_like","name":"zeros_like","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["a","dtype","order","subok","shape","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zeros_like","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.zeros_like#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,5],"arg_names":["a","dtype","order","subok","shape","device"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.zeros_like","name":"zeros_like","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,5],"arg_names":["a","dtype","order","subok","shape","device"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zeros_like","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.zeros_like#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.zeros_like","name":"zeros_like","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,5],"arg_names":["a","dtype","order","subok","shape","device"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zeros_like","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.zeros_like#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,5],"arg_names":["a","dtype","order","subok","shape","device"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.numeric.zeros_like","name":"zeros_like","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["a","dtype","order","subok","shape","device"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zeros_like","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.numeric.zeros_like","name":"zeros_like","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["a","dtype","order","subok","shape","device"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zeros_like","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["a","dtype","order","subok","shape","device"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.numeric.zeros_like#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zeros_like","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.numeric.zeros_like#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.numeric.zeros_like#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["a","dtype","order","subok","shape","device"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zeros_like","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.zeros_like#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,5],"arg_names":["a","dtype","order","subok","shape","device"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zeros_like","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.numeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.numeric.zeros_like#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["a","dtype","order","subok","shape","device"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zeros_like","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_core/numeric.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/numeric.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/numeric.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..eaa2842cc662451115ee8b5205469f6702ad717b --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/numeric.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[71,76,1,50,2,17,1,1,1,1,1,1],"dep_prios":[5,5,5,5,5,5,5,30,30,30,30,30],"dependencies":["numpy._core.fromnumeric","numpy._core.multiarray","collections.abc","numpy._typing","typing","numpy","builtins","_frozen_importlib","abc","numpy._typing._array_like","numpy._typing._dtype_like","numpy._typing._nested_sequence"],"hash":"773588ac55e2f66cf0e2cc14f9c04ed93732c386","id":"numpy._core.numeric","ignore_all":true,"interface_hash":"443710fee2b72101be18e1ee776b02aeccbc7978","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_core/numeric.pyi","plugin_data":null,"size":19042,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/numerictypes.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/numerictypes.data.json new file mode 100644 index 0000000000000000000000000000000000000000..a0c432aa1824ed6fc35bb61c65b4eed560575817 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/numerictypes.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy._core.numerictypes","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"DTypeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like.DTypeLike","kind":"Gdef","module_hidden":true,"module_public":false},"Final":{".class":"SymbolTableNode","cross_ref":"typing.Final","kind":"Gdef","module_hidden":true,"module_public":false},"L":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"ScalarType":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy._core.numerictypes.ScalarType","name":"ScalarType","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":[{".class":"TypeType","item":"builtins.int"},{".class":"TypeType","item":"builtins.float"},{".class":"TypeType","item":"builtins.complex"},{".class":"TypeType","item":"builtins.bool"},{".class":"TypeType","item":"builtins.bytes"},{".class":"TypeType","item":"builtins.str"},{".class":"TypeType","item":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.memoryview"}},{".class":"TypeType","item":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeType","item":"numpy.complex128"},{".class":"UnionType","items":[{".class":"TypeType","item":"numpy.complex128"},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._96Bit","numpy._typing._nbit_base._96Bit"],"extra_attrs":null,"type_ref":"numpy.complexfloating"}},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._128Bit","numpy._typing._nbit_base._128Bit"],"extra_attrs":null,"type_ref":"numpy.complexfloating"}}],"uses_pep604_syntax":false},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeType","item":"numpy.float64"},{".class":"UnionType","items":[{".class":"TypeType","item":"numpy.float64"},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._96Bit"],"extra_attrs":null,"type_ref":"numpy.floating"}},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._128Bit"],"extra_attrs":null,"type_ref":"numpy.floating"}}],"uses_pep604_syntax":false},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._8Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._16Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._32Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"UnionType","items":[{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._32Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._64Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}}],"uses_pep604_syntax":false},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._64Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeType","item":{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"}},{".class":"TypeType","item":{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"}},{".class":"TypeType","item":"numpy.object_"},{".class":"TypeType","item":"numpy.bytes_"},{".class":"TypeType","item":"numpy.str_"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"UnionType","items":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}}],"uses_pep604_syntax":false},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeType","item":"numpy.void"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"TypedDict":{".class":"SymbolTableNode","cross_ref":"typing.TypedDict","kind":"Gdef","module_hidden":true,"module_public":false},"_TypeCodes":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._core.numerictypes._TypeCodes","name":"_TypeCodes","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy._core.numerictypes._TypeCodes","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._core.numerictypes","mro":["numpy._core.numerictypes._TypeCodes","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["Character",{".class":"LiteralType","fallback":"builtins.str","value":"c"}],["Integer",{".class":"LiteralType","fallback":"builtins.str","value":"bhilqnp"}],["UnsignedInteger",{".class":"LiteralType","fallback":"builtins.str","value":"BHILQNP"}],["Float",{".class":"LiteralType","fallback":"builtins.str","value":"efdg"}],["Complex",{".class":"LiteralType","fallback":"builtins.str","value":"FDG"}],["AllInteger",{".class":"LiteralType","fallback":"builtins.str","value":"bBhHiIlLqQnNpP"}],["AllFloat",{".class":"LiteralType","fallback":"builtins.str","value":"efdgFDG"}],["Datetime",{".class":"LiteralType","fallback":"builtins.str","value":"Mm"}],["All",{".class":"LiteralType","fallback":"builtins.str","value":"?bhilqnpBHILQNPefdgFDGSUVOMm"}]],"readonly_keys":[],"required_keys":["All","AllFloat","AllInteger","Character","Complex","Datetime","Float","Integer","UnsignedInteger"]}}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy._core.numerictypes.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.numerictypes.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.numerictypes.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.numerictypes.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.numerictypes.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.numerictypes.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.numerictypes.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"bool":{".class":"SymbolTableNode","cross_ref":"numpy.bool","kind":"Gdef"},"bool_":{".class":"SymbolTableNode","cross_ref":"numpy.bool_","kind":"Gdef"},"busday_count":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.busday_count","kind":"Gdef"},"busday_offset":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.busday_offset","kind":"Gdef"},"busdaycalendar":{".class":"SymbolTableNode","cross_ref":"numpy.busdaycalendar","kind":"Gdef"},"byte":{".class":"SymbolTableNode","cross_ref":"numpy.byte","kind":"Gdef"},"bytes_":{".class":"SymbolTableNode","cross_ref":"numpy.bytes_","kind":"Gdef"},"cdouble":{".class":"SymbolTableNode","cross_ref":"numpy.cdouble","kind":"Gdef"},"character":{".class":"SymbolTableNode","cross_ref":"numpy.character","kind":"Gdef"},"clongdouble":{".class":"SymbolTableNode","cross_ref":"numpy.clongdouble","kind":"Gdef"},"complex128":{".class":"SymbolTableNode","cross_ref":"numpy.complex128","kind":"Gdef"},"complex192":{".class":"SymbolTableNode","cross_ref":"numpy._typing._extended_precision.complex192","kind":"Gdef"},"complex256":{".class":"SymbolTableNode","cross_ref":"numpy._typing._extended_precision.complex256","kind":"Gdef"},"complex64":{".class":"SymbolTableNode","cross_ref":"numpy.complex64","kind":"Gdef"},"complexfloating":{".class":"SymbolTableNode","cross_ref":"numpy.complexfloating","kind":"Gdef"},"csingle":{".class":"SymbolTableNode","cross_ref":"numpy.csingle","kind":"Gdef"},"datetime64":{".class":"SymbolTableNode","cross_ref":"numpy.datetime64","kind":"Gdef"},"datetime_as_string":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.datetime_as_string","kind":"Gdef"},"datetime_data":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.datetime_data","kind":"Gdef"},"double":{".class":"SymbolTableNode","cross_ref":"numpy.double","kind":"Gdef"},"dtype":{".class":"SymbolTableNode","cross_ref":"numpy.dtype","kind":"Gdef","module_hidden":true,"module_public":false},"flexible":{".class":"SymbolTableNode","cross_ref":"numpy.flexible","kind":"Gdef"},"float128":{".class":"SymbolTableNode","cross_ref":"numpy._typing._extended_precision.float128","kind":"Gdef"},"float16":{".class":"SymbolTableNode","cross_ref":"numpy.float16","kind":"Gdef"},"float32":{".class":"SymbolTableNode","cross_ref":"numpy.float32","kind":"Gdef"},"float64":{".class":"SymbolTableNode","cross_ref":"numpy.float64","kind":"Gdef"},"float96":{".class":"SymbolTableNode","cross_ref":"numpy._typing._extended_precision.float96","kind":"Gdef"},"floating":{".class":"SymbolTableNode","cross_ref":"numpy.floating","kind":"Gdef"},"generic":{".class":"SymbolTableNode","cross_ref":"numpy.generic","kind":"Gdef"},"half":{".class":"SymbolTableNode","cross_ref":"numpy.half","kind":"Gdef"},"inexact":{".class":"SymbolTableNode","cross_ref":"numpy.inexact","kind":"Gdef"},"int16":{".class":"SymbolTableNode","cross_ref":"numpy.int16","kind":"Gdef"},"int32":{".class":"SymbolTableNode","cross_ref":"numpy.int32","kind":"Gdef"},"int64":{".class":"SymbolTableNode","cross_ref":"numpy.int64","kind":"Gdef"},"int8":{".class":"SymbolTableNode","cross_ref":"numpy.int8","kind":"Gdef"},"int_":{".class":"SymbolTableNode","cross_ref":"numpy.int_","kind":"Gdef"},"intc":{".class":"SymbolTableNode","cross_ref":"numpy.intc","kind":"Gdef"},"integer":{".class":"SymbolTableNode","cross_ref":"numpy.integer","kind":"Gdef"},"intp":{".class":"SymbolTableNode","cross_ref":"numpy.intp","kind":"Gdef"},"is_busday":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.is_busday","kind":"Gdef"},"isdtype":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["dtype","kind"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.numerictypes.isdtype","name":"isdtype","original_first_arg":"dtype","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["dtype","kind"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"builtins.type"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isdtype","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"issubdtype":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["arg1","arg2"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.numerictypes.issubdtype","name":"issubdtype","original_first_arg":"arg1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["arg1","arg2"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"issubdtype","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"long":{".class":"SymbolTableNode","cross_ref":"numpy.long","kind":"Gdef"},"longdouble":{".class":"SymbolTableNode","cross_ref":"numpy.longdouble","kind":"Gdef"},"longlong":{".class":"SymbolTableNode","cross_ref":"numpy.longlong","kind":"Gdef"},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"number":{".class":"SymbolTableNode","cross_ref":"numpy.number","kind":"Gdef"},"object_":{".class":"SymbolTableNode","cross_ref":"numpy.object_","kind":"Gdef"},"py_bool":{".class":"SymbolTableNode","cross_ref":"builtins.bool","kind":"Gdef","module_hidden":true,"module_public":false},"sctypeDict":{".class":"SymbolTableNode","cross_ref":"numpy._core._type_aliases.sctypeDict","kind":"Gdef","module_public":false},"short":{".class":"SymbolTableNode","cross_ref":"numpy.short","kind":"Gdef"},"signedinteger":{".class":"SymbolTableNode","cross_ref":"numpy.signedinteger","kind":"Gdef"},"single":{".class":"SymbolTableNode","cross_ref":"numpy.single","kind":"Gdef"},"str_":{".class":"SymbolTableNode","cross_ref":"numpy.str_","kind":"Gdef"},"timedelta64":{".class":"SymbolTableNode","cross_ref":"numpy.timedelta64","kind":"Gdef"},"typeDict":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"numpy._core.numerictypes.typeDict","name":"typeDict","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"TypeType","item":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"}}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"type_check_only":{".class":"SymbolTableNode","cross_ref":"typing.type_check_only","kind":"Gdef","module_hidden":true,"module_public":false},"typecodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy._core.numerictypes.typecodes","name":"typecodes","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"numpy._core.numerictypes._TypeCodes"}}},"ubyte":{".class":"SymbolTableNode","cross_ref":"numpy.ubyte","kind":"Gdef"},"uint":{".class":"SymbolTableNode","cross_ref":"numpy.uint","kind":"Gdef"},"uint16":{".class":"SymbolTableNode","cross_ref":"numpy.uint16","kind":"Gdef"},"uint32":{".class":"SymbolTableNode","cross_ref":"numpy.uint32","kind":"Gdef"},"uint64":{".class":"SymbolTableNode","cross_ref":"numpy.uint64","kind":"Gdef"},"uint8":{".class":"SymbolTableNode","cross_ref":"numpy.uint8","kind":"Gdef"},"uintc":{".class":"SymbolTableNode","cross_ref":"numpy.uintc","kind":"Gdef"},"uintp":{".class":"SymbolTableNode","cross_ref":"numpy.uintp","kind":"Gdef"},"ulong":{".class":"SymbolTableNode","cross_ref":"numpy.ulong","kind":"Gdef"},"ulonglong":{".class":"SymbolTableNode","cross_ref":"numpy.ulonglong","kind":"Gdef"},"unsignedinteger":{".class":"SymbolTableNode","cross_ref":"numpy.unsignedinteger","kind":"Gdef"},"ushort":{".class":"SymbolTableNode","cross_ref":"numpy.ushort","kind":"Gdef"},"void":{".class":"SymbolTableNode","cross_ref":"numpy.void","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_core/numerictypes.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/numerictypes.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/numerictypes.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..dcb25369589ec629e3d8d861de0d3865e67c0019 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/numerictypes.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[67,68,65,1,2,5,1,1,1,1],"dep_prios":[5,5,5,5,5,5,30,30,30,30],"dependencies":["numpy._core._type_aliases","numpy._core.multiarray","numpy._typing","builtins","typing","numpy","_frozen_importlib","abc","datetime","numpy._typing._nbit_base"],"hash":"1a23e2ad49da91311ed3fbd814127ed2125d4c6a","id":"numpy._core.numerictypes","ignore_all":true,"interface_hash":"8af7327d00b93cebd8aa191f8c6b22f0001f36f5","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_core/numerictypes.pyi","plugin_data":null,"size":3521,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/records.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/records.data.json new file mode 100644 index 0000000000000000000000000000000000000000..ecec4b52c683050405f365f63fa00c364520c4ad --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/records.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy._core.records","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"ClassVar":{".class":"SymbolTableNode","cross_ref":"typing.ClassVar","kind":"Gdef","module_hidden":true,"module_public":false},"DTypeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like.DTypeLike","kind":"Gdef","module_hidden":true,"module_public":false},"Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef","module_hidden":true,"module_public":false},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"Protocol":{".class":"SymbolTableNode","cross_ref":"typing.Protocol","kind":"Gdef","module_hidden":true,"module_public":false},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef","module_hidden":true,"module_public":false},"StrOrBytesPath":{".class":"SymbolTableNode","cross_ref":"_typeshed.StrOrBytesPath","kind":"Gdef","module_hidden":true,"module_public":false},"SupportsIndex":{".class":"SymbolTableNode","cross_ref":"typing.SupportsIndex","kind":"Gdef","module_hidden":true,"module_public":false},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy._core.records.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3}}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing_extensions.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"_AnyShape":{".class":"SymbolTableNode","cross_ref":"numpy._typing._shape._AnyShape","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeVoid_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeVoid_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ByteOrder":{".class":"SymbolTableNode","cross_ref":"numpy._ByteOrder","kind":"Gdef","module_hidden":true,"module_public":false},"_DTypeT_co":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.records._DTypeT_co","name":"_DTypeT_co","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}},"_NestedSequence":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nested_sequence._NestedSequence","kind":"Gdef","module_hidden":true,"module_public":false},"_OrderKACF":{".class":"SymbolTableNode","cross_ref":"numpy._OrderKACF","kind":"Gdef","module_hidden":true,"module_public":false},"_RecArray":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._core.records._RecArray","name":"_RecArray","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3}}},"_ScalarT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.records._ScalarT","name":"_ScalarT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},"_Shape":{".class":"SymbolTableNode","cross_ref":"numpy._typing._shape._Shape","kind":"Gdef","module_hidden":true,"module_public":false},"_ShapeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._shape._ShapeLike","kind":"Gdef","module_hidden":true,"module_public":false},"_ShapeT_co":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.records._ShapeT_co","name":"_ShapeT_co","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1}},"_SupportsBuffer":{".class":"SymbolTableNode","cross_ref":"numpy._SupportsBuffer","kind":"Gdef","module_hidden":true,"module_public":false},"_SupportsReadInto":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._core.records._SupportsReadInto","name":"_SupportsReadInto","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy._core.records._SupportsReadInto","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy._core.records","mro":["numpy._core.records._SupportsReadInto","builtins.object"],"names":{".class":"SymbolTable","readinto":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core.records._SupportsReadInto.readinto","name":"readinto","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy._core.records._SupportsReadInto",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.memoryview"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"readinto of _SupportsReadInto","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"seek":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":[null,null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core.records._SupportsReadInto.seek","name":"seek","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,null,null],"arg_types":["numpy._core.records._SupportsReadInto","builtins.int","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"seek of _SupportsReadInto","ret_type":"builtins.object","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"tell":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core.records._SupportsReadInto.tell","name":"tell","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["numpy._core.records._SupportsReadInto"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tell of _SupportsReadInto","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.records._SupportsReadInto.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy._core.records._SupportsReadInto","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_T":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.records._T","name":"_T","upper_bound":"builtins.object","values":[],"variance":0}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy._core.records.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.records.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.records.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.records.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.records.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.records.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.records.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"array":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.records.array","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1,1,1,1,1],"arg_names":["obj","dtype","shape","offset","strides","formats","names","titles","aligned","byteorder","copy"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.records.array","name":"array","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,1,1,1,1],"arg_names":["obj","dtype","shape","offset","strides","formats","names","titles","aligned","byteorder","copy"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.records._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.records.array#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.records._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.records.array#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.records.array","name":"array","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,1,1,1,1],"arg_names":["obj","dtype","shape","offset","strides","formats","names","titles","aligned","byteorder","copy"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.records._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.records.array#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.records._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.records.array#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,1,1,1,1],"arg_names":["obj","dtype","shape","offset","strides","formats","names","titles","aligned","byteorder","copy"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.records.array","name":"array","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1,1,1,1],"arg_names":["obj","dtype","shape","offset","strides","formats","names","titles","aligned","byteorder","copy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.records.array","name":"array","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1,1,1,1],"arg_names":["obj","dtype","shape","offset","strides","formats","names","titles","aligned","byteorder","copy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,3,5,5,5,5,5],"arg_names":["obj","dtype","shape","offset","strides","formats","names","titles","aligned","byteorder","copy"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.records.array","name":"array","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,3,5,5,5,5,5],"arg_names":["obj","dtype","shape","offset","strides","formats","names","titles","aligned","byteorder","copy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.records.array","name":"array","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,3,5,5,5,5,5],"arg_names":["obj","dtype","shape","offset","strides","formats","names","titles","aligned","byteorder","copy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1,1,1,1,1,1],"arg_names":["obj","dtype","shape","offset","strides","formats","names","titles","aligned","byteorder","copy"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.records.array","name":"array","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1,1,1,1,1],"arg_names":["obj","dtype","shape","offset","strides","formats","names","titles","aligned","byteorder","copy"],"arg_types":[{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"builtins.int",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.records.array","name":"array","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1,1,1,1,1],"arg_names":["obj","dtype","shape","offset","strides","formats","names","titles","aligned","byteorder","copy"],"arg_types":[{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"builtins.int",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3,5,5,3,5,5,5,5,5],"arg_names":["obj","dtype","shape","offset","strides","formats","names","titles","aligned","byteorder","copy"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.records.array","name":"array","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,1,3,5,5,3,5,5,5,5,5],"arg_names":["obj","dtype","shape","offset","strides","formats","names","titles","aligned","byteorder","copy"],"arg_types":[{".class":"NoneType"},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"builtins.int",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.records.array","name":"array","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3,5,5,3,5,5,5,5,5],"arg_names":["obj","dtype","shape","offset","strides","formats","names","titles","aligned","byteorder","copy"],"arg_types":[{".class":"NoneType"},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"builtins.int",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,1,1,1,1],"arg_names":["obj","dtype","shape","offset","strides","formats","names","titles","aligned","byteorder","copy"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.records.array","name":"array","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1,1,1,1],"arg_names":["obj","dtype","shape","offset","strides","formats","names","titles","aligned","byteorder","copy"],"arg_types":["numpy._core.records._SupportsReadInto",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.records.array","name":"array","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1,1,1,1],"arg_names":["obj","dtype","shape","offset","strides","formats","names","titles","aligned","byteorder","copy"],"arg_types":["numpy._core.records._SupportsReadInto",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,3,5,5,5,5,5],"arg_names":["obj","dtype","shape","offset","strides","formats","names","titles","aligned","byteorder","copy"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.records.array","name":"array","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,3,5,5,5,5,5],"arg_names":["obj","dtype","shape","offset","strides","formats","names","titles","aligned","byteorder","copy"],"arg_types":["numpy._core.records._SupportsReadInto",{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.records.array","name":"array","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,3,5,5,5,5,5],"arg_names":["obj","dtype","shape","offset","strides","formats","names","titles","aligned","byteorder","copy"],"arg_types":["numpy._core.records._SupportsReadInto",{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,1,1,1,1],"arg_names":["obj","dtype","shape","offset","strides","formats","names","titles","aligned","byteorder","copy"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.records._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.records.array#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.records._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.records.array#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1,1,1,1],"arg_names":["obj","dtype","shape","offset","strides","formats","names","titles","aligned","byteorder","copy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,3,5,5,5,5,5],"arg_names":["obj","dtype","shape","offset","strides","formats","names","titles","aligned","byteorder","copy"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1,1,1,1,1],"arg_names":["obj","dtype","shape","offset","strides","formats","names","titles","aligned","byteorder","copy"],"arg_types":[{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"builtins.int",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,3,5,5,3,5,5,5,5,5],"arg_names":["obj","dtype","shape","offset","strides","formats","names","titles","aligned","byteorder","copy"],"arg_types":[{".class":"NoneType"},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"builtins.int",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1,1,1,1],"arg_names":["obj","dtype","shape","offset","strides","formats","names","titles","aligned","byteorder","copy"],"arg_types":["numpy._core.records._SupportsReadInto",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,3,5,5,5,5,5],"arg_names":["obj","dtype","shape","offset","strides","formats","names","titles","aligned","byteorder","copy"],"arg_types":["numpy._core.records._SupportsReadInto",{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"find_duplicate":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["list"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.records.find_duplicate","name":"find_duplicate","original_first_arg":"list","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["list"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.records._T","id":-1,"name":"_T","namespace":"numpy._core.records.find_duplicate","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"find_duplicate","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.records._T","id":-1,"name":"_T","namespace":"numpy._core.records.find_duplicate","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.records._T","id":-1,"name":"_T","namespace":"numpy._core.records.find_duplicate","upper_bound":"builtins.object","values":[],"variance":0}]}}},"format_parser":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._core.records.format_parser","name":"format_parser","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy._core.records.format_parser","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._core.records","mro":["numpy._core.records.format_parser","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1,1],"arg_names":[null,"formats","names","titles","aligned","byteorder"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core.records.format_parser.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,1],"arg_names":[null,"formats","names","titles","aligned","byteorder"],"arg_types":["numpy._core.records.format_parser",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of format_parser","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"dtype":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy._core.records.format_parser.dtype","name":"dtype","setter_type":null,"type":{".class":"Instance","args":["numpy.void"],"extra_attrs":null,"type_ref":"numpy.dtype"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.records.format_parser.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy._core.records.format_parser","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"fromarrays":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.records.fromarrays","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1,1],"arg_names":["arrayList","dtype","shape","formats","names","titles","aligned","byteorder"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.records.fromarrays","name":"fromarrays","original_first_arg":"arrayList","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,1],"arg_names":["arrayList","dtype","shape","formats","names","titles","aligned","byteorder"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromarrays","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.records.fromarrays","name":"fromarrays","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,1],"arg_names":["arrayList","dtype","shape","formats","names","titles","aligned","byteorder"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromarrays","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,3,5,5,5,5],"arg_names":["arrayList","dtype","shape","formats","names","titles","aligned","byteorder"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.records.fromarrays","name":"fromarrays","original_first_arg":"arrayList","type":{".class":"CallableType","arg_kinds":[0,1,1,3,5,5,5,5],"arg_names":["arrayList","dtype","shape","formats","names","titles","aligned","byteorder"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromarrays","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.records.fromarrays","name":"fromarrays","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,3,5,5,5,5],"arg_names":["arrayList","dtype","shape","formats","names","titles","aligned","byteorder"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromarrays","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,1],"arg_names":["arrayList","dtype","shape","formats","names","titles","aligned","byteorder"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromarrays","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,3,5,5,5,5],"arg_names":["arrayList","dtype","shape","formats","names","titles","aligned","byteorder"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromarrays","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"fromfile":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.records.fromfile","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,1,1],"arg_names":["fd","dtype","shape","offset","formats","names","titles","aligned","byteorder"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.records.fromfile","name":"fromfile","original_first_arg":"fd","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1,1],"arg_names":["fd","dtype","shape","offset","formats","names","titles","aligned","byteorder"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.StrOrBytesPath"},"numpy._core.records._SupportsReadInto"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromfile","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.records.fromfile","name":"fromfile","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1,1],"arg_names":["fd","dtype","shape","offset","formats","names","titles","aligned","byteorder"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.StrOrBytesPath"},"numpy._core.records._SupportsReadInto"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromfile","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,3,5,5,5,5],"arg_names":["fd","dtype","shape","offset","formats","names","titles","aligned","byteorder"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.records.fromfile","name":"fromfile","original_first_arg":"fd","type":{".class":"CallableType","arg_kinds":[0,1,1,1,3,5,5,5,5],"arg_names":["fd","dtype","shape","offset","formats","names","titles","aligned","byteorder"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.StrOrBytesPath"},"numpy._core.records._SupportsReadInto"],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromfile","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.records.fromfile","name":"fromfile","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,3,5,5,5,5],"arg_names":["fd","dtype","shape","offset","formats","names","titles","aligned","byteorder"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.StrOrBytesPath"},"numpy._core.records._SupportsReadInto"],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromfile","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1,1],"arg_names":["fd","dtype","shape","offset","formats","names","titles","aligned","byteorder"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.StrOrBytesPath"},"numpy._core.records._SupportsReadInto"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromfile","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,3,5,5,5,5],"arg_names":["fd","dtype","shape","offset","formats","names","titles","aligned","byteorder"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.StrOrBytesPath"},"numpy._core.records._SupportsReadInto"],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromfile","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"fromrecords":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.records.fromrecords","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1,1],"arg_names":["recList","dtype","shape","formats","names","titles","aligned","byteorder"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.records.fromrecords","name":"fromrecords","original_first_arg":"recList","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,1],"arg_names":["recList","dtype","shape","formats","names","titles","aligned","byteorder"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["builtins.object"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"Instance","args":[{".class":"Instance","args":["builtins.object"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromrecords","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.records.fromrecords","name":"fromrecords","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,1],"arg_names":["recList","dtype","shape","formats","names","titles","aligned","byteorder"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["builtins.object"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"Instance","args":[{".class":"Instance","args":["builtins.object"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromrecords","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,3,5,5,5,5],"arg_names":["recList","dtype","shape","formats","names","titles","aligned","byteorder"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.records.fromrecords","name":"fromrecords","original_first_arg":"recList","type":{".class":"CallableType","arg_kinds":[0,1,1,3,5,5,5,5],"arg_names":["recList","dtype","shape","formats","names","titles","aligned","byteorder"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["builtins.object"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"Instance","args":[{".class":"Instance","args":["builtins.object"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromrecords","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.records.fromrecords","name":"fromrecords","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,3,5,5,5,5],"arg_names":["recList","dtype","shape","formats","names","titles","aligned","byteorder"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["builtins.object"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"Instance","args":[{".class":"Instance","args":["builtins.object"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromrecords","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,1],"arg_names":["recList","dtype","shape","formats","names","titles","aligned","byteorder"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["builtins.object"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"Instance","args":[{".class":"Instance","args":["builtins.object"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromrecords","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,3,5,5,5,5],"arg_names":["recList","dtype","shape","formats","names","titles","aligned","byteorder"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["builtins.object"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"Instance","args":[{".class":"Instance","args":["builtins.object"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromrecords","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"fromstring":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.records.fromstring","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,1,1],"arg_names":["datastring","dtype","shape","offset","formats","names","titles","aligned","byteorder"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.records.fromstring","name":"fromstring","original_first_arg":"datastring","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1,1],"arg_names":["datastring","dtype","shape","offset","formats","names","titles","aligned","byteorder"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromstring","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.records.fromstring","name":"fromstring","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1,1],"arg_names":["datastring","dtype","shape","offset","formats","names","titles","aligned","byteorder"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromstring","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,3,5,5,5,5],"arg_names":["datastring","dtype","shape","offset","formats","names","titles","aligned","byteorder"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.records.fromstring","name":"fromstring","original_first_arg":"datastring","type":{".class":"CallableType","arg_kinds":[0,1,1,1,3,5,5,5,5],"arg_names":["datastring","dtype","shape","offset","formats","names","titles","aligned","byteorder"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromstring","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.records.fromstring","name":"fromstring","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,3,5,5,5,5],"arg_names":["datastring","dtype","shape","offset","formats","names","titles","aligned","byteorder"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromstring","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1,1],"arg_names":["datastring","dtype","shape","offset","formats","names","titles","aligned","byteorder"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromstring","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,3,5,5,5,5],"arg_names":["datastring","dtype","shape","offset","formats","names","titles","aligned","byteorder"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromstring","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false},"recarray":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.records._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.records.recarray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.records._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy._core.records.recarray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ndarray"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._core.records.recarray","name":"recarray","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.records._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.records.recarray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.records._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy._core.records.recarray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy._core.records.recarray","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._core.records","mro":["numpy._core.records.recarray","numpy.ndarray","numpy._ArrayOrScalarCommon","builtins.object"],"names":{".class":"SymbolTable","__array_finalize__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core.records.recarray.__array_finalize__","name":"__array_finalize__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"obj"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.records._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.records.recarray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.records._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy._core.records.recarray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.records.recarray"},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__array_finalize__ of recarray","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__getattribute__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core.records.recarray.__getattribute__","name":"__getattribute__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.records._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.records.recarray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.records._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy._core.records.recarray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.records.recarray"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getattribute__ of recarray","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__module__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"numpy._core.records.recarray.__module__","name":"__module__","setter_type":null,"type":{".class":"LiteralType","fallback":"builtins.str","value":"numpy"}}},"__name__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready","has_explicit_value"],"fullname":"numpy._core.records.recarray.__name__","name":"__name__","setter_type":null,"type":{".class":"LiteralType","fallback":"builtins.str","value":"record"}}},"__new__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":["is_static"],"fullname":"numpy._core.records.recarray.__new__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,3,5,5,5,5,5],"arg_names":["subtype","shape","dtype","buf","offset","strides","formats","names","titles","byteorder","aligned","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._core.records.recarray.__new__","name":"__new__","original_first_arg":"subtype","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,3,5,5,5,5,5],"arg_names":["subtype","shape","dtype","buf","offset","strides","formats","names","titles","byteorder","aligned","order"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.records._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.records.recarray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.records._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy._core.records.recarray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.records.recarray"}},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of recarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.records.recarray.__new__","name":"__new__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,3,5,5,5,5,5],"arg_names":["subtype","shape","dtype","buf","offset","strides","formats","names","titles","byteorder","aligned","order"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.records._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.records.recarray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.records._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy._core.records.recarray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.records.recarray"}},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of recarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1,1,1,1,1,1,1],"arg_names":["subtype","shape","dtype","buf","offset","strides","formats","names","titles","byteorder","aligned","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._core.records.recarray.__new__","name":"__new__","original_first_arg":"subtype","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1,1,1,1,1,1],"arg_names":["subtype","shape","dtype","buf","offset","strides","formats","names","titles","byteorder","aligned","order"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.records._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.records.recarray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.records._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy._core.records.recarray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.records.recarray"}},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of recarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.records.recarray.__new__","name":"__new__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1,1,1,1,1,1],"arg_names":["subtype","shape","dtype","buf","offset","strides","formats","names","titles","byteorder","aligned","order"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.records._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.records.recarray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.records._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy._core.records.recarray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.records.recarray"}},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of recarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,3,5,5,5,5,5],"arg_names":["subtype","shape","dtype","buf","offset","strides","formats","names","titles","byteorder","aligned","order"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.records._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.records.recarray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.records._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy._core.records.recarray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.records.recarray"}},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of recarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1,1,1,1,1,1],"arg_names":["subtype","shape","dtype","buf","offset","strides","formats","names","titles","byteorder","aligned","order"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.records._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.records.recarray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.records._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy._core.records.recarray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.records.recarray"}},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of recarray","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.records.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"__setattr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":[null,null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core.records.recarray.__setattr__","name":"__setattr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.records._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.records.recarray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.records._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy._core.records.recarray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.records.recarray"},"builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__setattr__ of recarray","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"field":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.records.recarray.field","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":[null,"attr","val"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._core.records.recarray.field","name":"field","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"attr","val"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.records._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.records.recarray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.records._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy._core.records.recarray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.records.recarray"},{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"field of recarray","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.records.recarray.field","name":"field","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"attr","val"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.records._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.records.recarray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.records._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy._core.records.recarray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.records.recarray"},{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"field of recarray","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":[null,"attr","val"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._core.records.recarray.field","name":"field","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":[null,"attr","val"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.records._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.records.recarray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.records._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy._core.records.recarray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.records.recarray"},{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"field of recarray","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.records.recarray.field","name":"field","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":[null,"attr","val"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.records._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.records.recarray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.records._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy._core.records.recarray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.records.recarray"},{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"field of recarray","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"attr","val"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.records._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.records.recarray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.records._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy._core.records.recarray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.records.recarray"},{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"field of recarray","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":[null,"attr","val"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.records._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.records.recarray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.records._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy._core.records.recarray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.records.recarray"},{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"field of recarray","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.records.recarray.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy._core.records._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy._core.records.recarray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy._core.records._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy._core.records.recarray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._core.records.recarray"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_ShapeT_co","_DTypeT_co"],"typeddict_type":null}},"record":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy.void"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._core.records.record","name":"record","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy._core.records.record","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._core.records","mro":["numpy._core.records.record","numpy.void","numpy.flexible","numpy._RealMixin","numpy.generic","numpy._ArrayOrScalarCommon","builtins.object"],"names":{".class":"SymbolTable","__getattribute__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core.records.record.__getattribute__","name":"__getattribute__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy._core.records.record","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getattribute__ of record","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__getitem__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.records.record.__getitem__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._core.records.record.__getitem__","name":"__getitem__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy._core.records.record",{".class":"UnionType","items":["builtins.str","typing.SupportsIndex"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of record","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.records.record.__getitem__","name":"__getitem__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy._core.records.record",{".class":"UnionType","items":["builtins.str","typing.SupportsIndex"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of record","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._core.records.record.__getitem__","name":"__getitem__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy._core.records.record",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of record","ret_type":"numpy._core.records.record","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.records.record.__getitem__","name":"__getitem__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy._core.records.record",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of record","ret_type":"numpy._core.records.record","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy._core.records.record",{".class":"UnionType","items":["builtins.str","typing.SupportsIndex"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of record","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy._core.records.record",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of record","ret_type":"numpy._core.records.record","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"__setattr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","attr","val"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core.records.record.__setattr__","name":"__setattr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","attr","val"],"arg_types":["numpy._core.records.record","builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__setattr__ of record","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"pprint":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._core.records.record.pprint","name":"pprint","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy._core.records.record"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pprint of record","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.records.record.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy._core.records.record","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"type_check_only":{".class":"SymbolTableNode","cross_ref":"typing.type_check_only","kind":"Gdef","module_hidden":true,"module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_core/records.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/records.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/records.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..4e731f2c67abd634c28610085485f55dcc38aad4 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/records.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[3,20,4,15,16,18,1,1,1,1,1],"dep_prios":[5,5,5,5,5,5,5,30,30,30,30],"dependencies":["collections.abc","numpy._typing","typing","_typeshed","typing_extensions","numpy","builtins","_frozen_importlib","abc","numpy._typing._nested_sequence","os"],"hash":"0d22de6a29d6f65011929bae22cf2ff50eb66158","id":"numpy._core.records","ignore_all":true,"interface_hash":"cf202b09d55ddd8ec05b61a37bb06f1f81a0ca86","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_core/records.pyi","plugin_data":null,"size":8935,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/shape_base.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/shape_base.data.json new file mode 100644 index 0000000000000000000000000000000000000000..09281d03a4c8c5fc7f6d2d87334378e2a7ef125c --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/shape_base.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy._core.shape_base","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"DTypeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like.DTypeLike","kind":"Gdef","module_hidden":true,"module_public":false},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef","module_hidden":true,"module_public":false},"SupportsIndex":{".class":"SymbolTableNode","cross_ref":"typing.SupportsIndex","kind":"Gdef","module_hidden":true,"module_public":false},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ArrayT","name":"_ArrayT","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}},"_CastingKind":{".class":"SymbolTableNode","cross_ref":"numpy._CastingKind","kind":"Gdef","module_hidden":true,"module_public":false},"_DTypeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._DTypeLike","kind":"Gdef","module_hidden":true,"module_public":false},"_ScalarT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","name":"_ScalarT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},"_ScalarT1":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT1","name":"_ScalarT1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},"_ScalarT2":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT2","name":"_ScalarT2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy._core.shape_base.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.shape_base.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.shape_base.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.shape_base.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.shape_base.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.shape_base.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.shape_base.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"atleast_1d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.shape_base.atleast_1d","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.shape_base.atleast_1d","name":"atleast_1d","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_1d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.atleast_1d#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.shape_base.atleast_1d","name":"atleast_1d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_1d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.atleast_1d#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.shape_base.atleast_1d","name":"atleast_1d","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_1d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT1","id":-1,"name":"_ScalarT1","namespace":"numpy._core.shape_base.atleast_1d#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT2","id":-2,"name":"_ScalarT2","namespace":"numpy._core.shape_base.atleast_1d#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.shape_base.atleast_1d","name":"atleast_1d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_1d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT1","id":-1,"name":"_ScalarT1","namespace":"numpy._core.shape_base.atleast_1d#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT2","id":-2,"name":"_ScalarT2","namespace":"numpy._core.shape_base.atleast_1d#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,2],"arg_names":[null,null,"arys"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.shape_base.atleast_1d","name":"atleast_1d","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"arys"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_1d","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.atleast_1d#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.shape_base.atleast_1d","name":"atleast_1d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"arys"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_1d","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.atleast_1d#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.shape_base.atleast_1d","name":"atleast_1d","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_1d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.shape_base.atleast_1d","name":"atleast_1d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_1d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.shape_base.atleast_1d","name":"atleast_1d","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_1d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.shape_base.atleast_1d","name":"atleast_1d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_1d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.shape_base.atleast_1d","name":"atleast_1d","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_1d","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.shape_base.atleast_1d","name":"atleast_1d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_1d","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_1d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.atleast_1d#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_1d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT1","id":-1,"name":"_ScalarT1","namespace":"numpy._core.shape_base.atleast_1d#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT2","id":-2,"name":"_ScalarT2","namespace":"numpy._core.shape_base.atleast_1d#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"arys"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_1d","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.atleast_1d#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_1d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_1d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_1d","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"atleast_2d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.shape_base.atleast_2d","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.shape_base.atleast_2d","name":"atleast_2d","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_2d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.atleast_2d#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.shape_base.atleast_2d","name":"atleast_2d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_2d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.atleast_2d#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.shape_base.atleast_2d","name":"atleast_2d","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT1","id":-1,"name":"_ScalarT1","namespace":"numpy._core.shape_base.atleast_2d#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT2","id":-2,"name":"_ScalarT2","namespace":"numpy._core.shape_base.atleast_2d#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.shape_base.atleast_2d","name":"atleast_2d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT1","id":-1,"name":"_ScalarT1","namespace":"numpy._core.shape_base.atleast_2d#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT2","id":-2,"name":"_ScalarT2","namespace":"numpy._core.shape_base.atleast_2d#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,2],"arg_names":[null,null,"arys"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.shape_base.atleast_2d","name":"atleast_2d","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"arys"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_2d","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.atleast_2d#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.shape_base.atleast_2d","name":"atleast_2d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"arys"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_2d","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.atleast_2d#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.shape_base.atleast_2d","name":"atleast_2d","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_2d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.shape_base.atleast_2d","name":"atleast_2d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_2d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.shape_base.atleast_2d","name":"atleast_2d","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.shape_base.atleast_2d","name":"atleast_2d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.shape_base.atleast_2d","name":"atleast_2d","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_2d","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.shape_base.atleast_2d","name":"atleast_2d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_2d","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_2d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.atleast_2d#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT1","id":-1,"name":"_ScalarT1","namespace":"numpy._core.shape_base.atleast_2d#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT2","id":-2,"name":"_ScalarT2","namespace":"numpy._core.shape_base.atleast_2d#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"arys"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_2d","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.atleast_2d#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_2d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_2d","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"atleast_3d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.shape_base.atleast_3d","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.shape_base.atleast_3d","name":"atleast_3d","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_3d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.atleast_3d#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.shape_base.atleast_3d","name":"atleast_3d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_3d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.atleast_3d#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.shape_base.atleast_3d","name":"atleast_3d","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_3d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT1","id":-1,"name":"_ScalarT1","namespace":"numpy._core.shape_base.atleast_3d#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT2","id":-2,"name":"_ScalarT2","namespace":"numpy._core.shape_base.atleast_3d#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.shape_base.atleast_3d","name":"atleast_3d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_3d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT1","id":-1,"name":"_ScalarT1","namespace":"numpy._core.shape_base.atleast_3d#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT2","id":-2,"name":"_ScalarT2","namespace":"numpy._core.shape_base.atleast_3d#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,2],"arg_names":[null,null,"arys"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.shape_base.atleast_3d","name":"atleast_3d","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"arys"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_3d","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.atleast_3d#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.shape_base.atleast_3d","name":"atleast_3d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"arys"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_3d","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.atleast_3d#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.shape_base.atleast_3d","name":"atleast_3d","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_3d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.shape_base.atleast_3d","name":"atleast_3d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_3d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.shape_base.atleast_3d","name":"atleast_3d","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_3d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.shape_base.atleast_3d","name":"atleast_3d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_3d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.shape_base.atleast_3d","name":"atleast_3d","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_3d","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.shape_base.atleast_3d","name":"atleast_3d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_3d","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_3d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.atleast_3d#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_3d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT1","id":-1,"name":"_ScalarT1","namespace":"numpy._core.shape_base.atleast_3d#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT2","id":-2,"name":"_ScalarT2","namespace":"numpy._core.shape_base.atleast_3d#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"arys"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_3d","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.atleast_3d#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_3d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_3d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"atleast_3d","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"block":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.shape_base.block","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["arrays"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.shape_base.block","name":"block","original_first_arg":"arrays","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["arrays"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"block","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.block#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.shape_base.block","name":"block","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["arrays"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"block","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.block#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["arrays"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.shape_base.block","name":"block","original_first_arg":"arrays","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["arrays"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"block","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.shape_base.block","name":"block","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["arrays"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"block","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["arrays"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"block","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.block#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0],"arg_names":["arrays"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"block","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"generic":{".class":"SymbolTableNode","cross_ref":"numpy.generic","kind":"Gdef","module_hidden":true,"module_public":false},"hstack":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.shape_base.hstack","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5],"arg_names":["tup","dtype","casting"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.shape_base.hstack","name":"hstack","original_first_arg":"tup","type":{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":["tup","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hstack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.hstack#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.shape_base.hstack","name":"hstack","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":["tup","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hstack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.hstack#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,5],"arg_names":["tup","dtype","casting"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.shape_base.hstack","name":"hstack","original_first_arg":"tup","type":{".class":"CallableType","arg_kinds":[0,3,5],"arg_names":["tup","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hstack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.hstack#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.shape_base.hstack","name":"hstack","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,3,5],"arg_names":["tup","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hstack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.hstack#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5],"arg_names":["tup","dtype","casting"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.shape_base.hstack","name":"hstack","original_first_arg":"tup","type":{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":["tup","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hstack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.shape_base.hstack","name":"hstack","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":["tup","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hstack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":["tup","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hstack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.hstack#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,3,5],"arg_names":["tup","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hstack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.hstack#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":["tup","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hstack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false},"stack":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.shape_base.stack","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,5,5],"arg_names":["arrays","axis","out","dtype","casting"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.shape_base.stack","name":"stack","original_first_arg":"arrays","type":{".class":"CallableType","arg_kinds":[0,1,1,5,5],"arg_names":["arrays","axis","out","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},"typing.SupportsIndex",{".class":"NoneType"},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"stack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.stack#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.shape_base.stack","name":"stack","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,5,5],"arg_names":["arrays","axis","out","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},"typing.SupportsIndex",{".class":"NoneType"},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"stack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.stack#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,3,5],"arg_names":["arrays","axis","out","dtype","casting"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.shape_base.stack","name":"stack","original_first_arg":"arrays","type":{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["arrays","axis","out","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},"typing.SupportsIndex",{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"stack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.stack#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.shape_base.stack","name":"stack","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["arrays","axis","out","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},"typing.SupportsIndex",{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"stack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.stack#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,5,5],"arg_names":["arrays","axis","out","dtype","casting"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.shape_base.stack","name":"stack","original_first_arg":"arrays","type":{".class":"CallableType","arg_kinds":[0,1,1,5,5],"arg_names":["arrays","axis","out","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},"typing.SupportsIndex",{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"stack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.shape_base.stack","name":"stack","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,5,5],"arg_names":["arrays","axis","out","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},"typing.SupportsIndex",{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"stack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5,5],"arg_names":["arrays","axis","out","dtype","casting"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.shape_base.stack","name":"stack","original_first_arg":"arrays","type":{".class":"CallableType","arg_kinds":[0,0,0,5,5],"arg_names":["arrays","axis","out","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},"typing.SupportsIndex",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.shape_base.stack#3","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"stack","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.shape_base.stack#3","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.shape_base.stack#3","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.shape_base.stack","name":"stack","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,5,5],"arg_names":["arrays","axis","out","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},"typing.SupportsIndex",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.shape_base.stack#3","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"stack","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.shape_base.stack#3","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.shape_base.stack#3","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3,5,5],"arg_names":["arrays","axis","out","dtype","casting"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.shape_base.stack","name":"stack","original_first_arg":"arrays","type":{".class":"CallableType","arg_kinds":[0,1,3,5,5],"arg_names":["arrays","axis","out","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},"typing.SupportsIndex",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.shape_base.stack","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"stack","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.shape_base.stack","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.shape_base.stack","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.shape_base.stack","name":"stack","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3,5,5],"arg_names":["arrays","axis","out","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},"typing.SupportsIndex",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.shape_base.stack","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"stack","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.shape_base.stack","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.shape_base.stack","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,5,5],"arg_names":["arrays","axis","out","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},"typing.SupportsIndex",{".class":"NoneType"},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"stack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.stack#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["arrays","axis","out","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},"typing.SupportsIndex",{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"stack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.stack#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,5,5],"arg_names":["arrays","axis","out","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},"typing.SupportsIndex",{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"stack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,5,5],"arg_names":["arrays","axis","out","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},"typing.SupportsIndex",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.shape_base.stack#3","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"stack","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.shape_base.stack#3","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.shape_base.stack#3","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5,5],"arg_names":["arrays","axis","out","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},"typing.SupportsIndex",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.shape_base.stack","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"stack","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.shape_base.stack","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.shape_base.stack","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}]}}},"unstack":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.shape_base.unstack","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5],"arg_names":[null,"axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.shape_base.unstack","name":"unstack","original_first_arg":"array","type":{".class":"CallableType","arg_kinds":[0,5],"arg_names":[null,"axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unstack","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.unstack#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.shape_base.unstack","name":"unstack","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5],"arg_names":[null,"axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unstack","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.unstack#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5],"arg_names":[null,"axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.shape_base.unstack","name":"unstack","original_first_arg":"array","type":{".class":"CallableType","arg_kinds":[0,5],"arg_names":[null,"axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unstack","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.shape_base.unstack","name":"unstack","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5],"arg_names":[null,"axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unstack","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,5],"arg_names":[null,"axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unstack","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.unstack#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,5],"arg_names":[null,"axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unstack","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"vstack":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.shape_base.vstack","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5],"arg_names":["tup","dtype","casting"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.shape_base.vstack","name":"vstack","original_first_arg":"tup","type":{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":["tup","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vstack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.vstack#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.shape_base.vstack","name":"vstack","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":["tup","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vstack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.vstack#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,5],"arg_names":["tup","dtype","casting"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.shape_base.vstack","name":"vstack","original_first_arg":"tup","type":{".class":"CallableType","arg_kinds":[0,3,5],"arg_names":["tup","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vstack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.vstack#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.shape_base.vstack","name":"vstack","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,3,5],"arg_names":["tup","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vstack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.vstack#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5],"arg_names":["tup","dtype","casting"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.shape_base.vstack","name":"vstack","original_first_arg":"tup","type":{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":["tup","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vstack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.shape_base.vstack","name":"vstack","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":["tup","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vstack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":["tup","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vstack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.vstack#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,3,5],"arg_names":["tup","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vstack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.shape_base._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.shape_base.vstack#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":["tup","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vstack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_core/shape_base.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/shape_base.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/shape_base.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..e307a41b6ec68f612c19aac1528a307a4d64db80 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/shape_base.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,5,2,4,1,1,1],"dep_prios":[5,5,5,5,5,30,30],"dependencies":["collections.abc","numpy._typing","typing","numpy","builtins","_frozen_importlib","abc"],"hash":"44713a3ebc4239fbe28181f1ae679e8a87dc41b9","id":"numpy._core.shape_base","ignore_all":true,"interface_hash":"c4c8dda8c1e86602cce878ecc11f8bd534eeb882","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_core/shape_base.pyi","plugin_data":null,"size":4753,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/strings.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/strings.data.json new file mode 100644 index 0000000000000000000000000000000000000000..db838f9084e99e09e854b6982d4577f9a3ac2b33 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/strings.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy._core.strings","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"S_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeBytes_co","kind":"Gdef","module_hidden":true,"module_public":false},"T_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeString_co","kind":"Gdef","module_hidden":true,"module_public":false},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy._core.strings.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3}}},"UST_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeAnyString_co","kind":"Gdef","module_hidden":true,"module_public":false},"U_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeStr_co","kind":"Gdef","module_hidden":true,"module_public":false},"_AnyShape":{".class":"SymbolTableNode","cross_ref":"numpy._typing._shape._AnyShape","kind":"Gdef","module_hidden":true,"module_public":false},"_StringDTypeArray":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._core.strings._StringDTypeArray","name":"_StringDTypeArray","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3}}},"_StringDTypeOrUnicodeArray":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._core.strings._StringDTypeOrUnicodeArray","name":"_StringDTypeOrUnicodeArray","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3}}},"_StringDTypeSupportsArray":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._core.strings._StringDTypeSupportsArray","name":"_StringDTypeSupportsArray","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3}}},"_SupportsArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._SupportsArray","kind":"Gdef","module_hidden":true,"module_public":false},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy._core.strings.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.strings.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.strings.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.strings.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.strings.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.strings.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._core.strings.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"add":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.strings.add","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.add","name":"add","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.add","name":"add","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.add","name":"add","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.add","name":"add","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.add","name":"add","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.add","name":"add","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.add","name":"add","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.add","name":"add","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"capitalize":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.strings.capitalize","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.capitalize","name":"capitalize","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"capitalize","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.capitalize","name":"capitalize","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"capitalize","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.capitalize","name":"capitalize","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"capitalize","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.capitalize","name":"capitalize","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"capitalize","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.capitalize","name":"capitalize","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"capitalize","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.capitalize","name":"capitalize","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"capitalize","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.capitalize","name":"capitalize","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"capitalize","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.capitalize","name":"capitalize","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"capitalize","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"capitalize","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"capitalize","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"capitalize","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"capitalize","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"center":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.strings.center","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.center","name":"center","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"center","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.center","name":"center","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"center","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.center","name":"center","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"center","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.center","name":"center","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"center","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.center","name":"center","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"center","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.center","name":"center","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"center","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.center","name":"center","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"center","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.center","name":"center","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"center","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"center","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"center","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"center","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"center","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"count":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.strings.count","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.count","name":"count","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.count","name":"count","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.count","name":"count","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.count","name":"count","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.count","name":"count","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.count","name":"count","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"decode":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["a","encoding","errors"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.strings.decode","name":"decode","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","encoding","errors"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"decode","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"encode":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["a","encoding","errors"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.strings.encode","name":"encode","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","encoding","errors"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"encode","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"endswith":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.strings.endswith","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","suffix","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.endswith","name":"endswith","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","suffix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"endswith","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.endswith","name":"endswith","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","suffix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"endswith","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","suffix","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.endswith","name":"endswith","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","suffix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"endswith","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.endswith","name":"endswith","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","suffix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"endswith","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","suffix","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.endswith","name":"endswith","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","suffix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"endswith","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.endswith","name":"endswith","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","suffix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"endswith","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","suffix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"endswith","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","suffix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"endswith","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","suffix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"endswith","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"equal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.strings.equal","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.equal","name":"equal","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.equal","name":"equal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.equal","name":"equal","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.equal","name":"equal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.equal","name":"equal","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.equal","name":"equal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"expandtabs":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.strings.expandtabs","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","tabsize"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.expandtabs","name":"expandtabs","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tabsize"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"expandtabs","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.expandtabs","name":"expandtabs","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tabsize"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"expandtabs","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","tabsize"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.expandtabs","name":"expandtabs","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tabsize"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"expandtabs","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.expandtabs","name":"expandtabs","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tabsize"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"expandtabs","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","tabsize"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.expandtabs","name":"expandtabs","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tabsize"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"expandtabs","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.expandtabs","name":"expandtabs","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tabsize"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"expandtabs","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","tabsize"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.expandtabs","name":"expandtabs","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tabsize"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"expandtabs","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.expandtabs","name":"expandtabs","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tabsize"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"expandtabs","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tabsize"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"expandtabs","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tabsize"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"expandtabs","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tabsize"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"expandtabs","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tabsize"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"expandtabs","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"find":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.strings.find","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.find","name":"find","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"find","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.find","name":"find","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"find","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.find","name":"find","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"find","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.find","name":"find","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"find","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.find","name":"find","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"find","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.find","name":"find","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"find","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"find","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"find","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"find","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"greater":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.strings.greater","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.greater","name":"greater","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.greater","name":"greater","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.greater","name":"greater","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.greater","name":"greater","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.greater","name":"greater","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.greater","name":"greater","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"greater_equal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.strings.greater_equal","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.greater_equal","name":"greater_equal","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.greater_equal","name":"greater_equal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.greater_equal","name":"greater_equal","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.greater_equal","name":"greater_equal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.greater_equal","name":"greater_equal","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.greater_equal","name":"greater_equal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"i_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeInt_co","kind":"Gdef","module_hidden":true,"module_public":false},"index":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.strings.index","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.index","name":"index","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"index","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.index","name":"index","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"index","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.index","name":"index","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"index","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.index","name":"index","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"index","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.index","name":"index","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"index","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.index","name":"index","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"index","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"index","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"index","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"index","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"isalnum":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.strings.isalnum","name":"isalnum","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isalnum","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isalpha":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.strings.isalpha","name":"isalpha","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isalpha","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isdecimal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.strings.isdecimal","name":"isdecimal","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isdecimal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isdigit":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.strings.isdigit","name":"isdigit","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isdigit","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"islower":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.strings.islower","name":"islower","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"islower","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isnumeric":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.strings.isnumeric","name":"isnumeric","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isnumeric","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isspace":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.strings.isspace","name":"isspace","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isspace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"istitle":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.strings.istitle","name":"istitle","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"istitle","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isupper":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.strings.isupper","name":"isupper","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isupper","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"less":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.strings.less","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.less","name":"less","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.less","name":"less","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.less","name":"less","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.less","name":"less","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.less","name":"less","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.less","name":"less","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"less_equal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.strings.less_equal","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.less_equal","name":"less_equal","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.less_equal","name":"less_equal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.less_equal","name":"less_equal","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.less_equal","name":"less_equal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.less_equal","name":"less_equal","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.less_equal","name":"less_equal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"ljust":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.strings.ljust","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.ljust","name":"ljust","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ljust","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.ljust","name":"ljust","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ljust","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.ljust","name":"ljust","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ljust","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.ljust","name":"ljust","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ljust","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.ljust","name":"ljust","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ljust","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.ljust","name":"ljust","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ljust","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.ljust","name":"ljust","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ljust","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.ljust","name":"ljust","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ljust","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ljust","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ljust","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ljust","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ljust","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"lower":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.strings.lower","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.lower","name":"lower","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lower","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.lower","name":"lower","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lower","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.lower","name":"lower","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lower","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.lower","name":"lower","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lower","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.lower","name":"lower","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lower","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.lower","name":"lower","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lower","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.lower","name":"lower","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lower","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.lower","name":"lower","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lower","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lower","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lower","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lower","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lower","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"lstrip":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.strings.lstrip","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","chars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.lstrip","name":"lstrip","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.lstrip","name":"lstrip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","chars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.lstrip","name":"lstrip","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.lstrip","name":"lstrip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","chars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.lstrip","name":"lstrip","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.lstrip","name":"lstrip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","chars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.lstrip","name":"lstrip","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.lstrip","name":"lstrip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"mod":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.strings.mod","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.mod","name":"mod","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","value"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.mod","name":"mod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","value"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.mod","name":"mod","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","value"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.mod","name":"mod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","value"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.mod","name":"mod","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","value"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mod","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.mod","name":"mod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","value"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mod","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.mod","name":"mod","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","value"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mod","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.mod","name":"mod","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","value"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mod","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","value"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","value"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mod","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","value"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mod","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","value"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mod","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"multiply":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.strings.multiply","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","i"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.multiply","name":"multiply","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","i"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"multiply","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.multiply","name":"multiply","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","i"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"multiply","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","i"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.multiply","name":"multiply","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","i"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"multiply","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.multiply","name":"multiply","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","i"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"multiply","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","i"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.multiply","name":"multiply","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","i"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"multiply","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.multiply","name":"multiply","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","i"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"multiply","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","i"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.multiply","name":"multiply","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","i"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"multiply","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.multiply","name":"multiply","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","i"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"multiply","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","i"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"multiply","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","i"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"multiply","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","i"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"multiply","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","i"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"multiply","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"not_equal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.strings.not_equal","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.not_equal","name":"not_equal","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"not_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.not_equal","name":"not_equal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"not_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.not_equal","name":"not_equal","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"not_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.not_equal","name":"not_equal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"not_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x1","x2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.not_equal","name":"not_equal","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"not_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.not_equal","name":"not_equal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"not_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"not_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"not_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x1","x2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"not_equal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false},"partition":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.strings.partition","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","sep"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.partition","name":"partition","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.partition","name":"partition","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","sep"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.partition","name":"partition","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.partition","name":"partition","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","sep"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.partition","name":"partition","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.partition","name":"partition","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","sep"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.partition","name":"partition","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.partition","name":"partition","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"replace":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.strings.replace","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["a","old","new","count"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.replace","name":"replace","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","old","new","count"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.replace","name":"replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","old","new","count"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["a","old","new","count"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.replace","name":"replace","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","old","new","count"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.replace","name":"replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","old","new","count"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["a","old","new","count"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.replace","name":"replace","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","old","new","count"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.replace","name":"replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","old","new","count"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["a","old","new","count"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.replace","name":"replace","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","old","new","count"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.replace","name":"replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","old","new","count"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","old","new","count"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","old","new","count"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","old","new","count"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","old","new","count"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"rfind":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.strings.rfind","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.rfind","name":"rfind","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rfind","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.rfind","name":"rfind","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rfind","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.rfind","name":"rfind","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rfind","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.rfind","name":"rfind","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rfind","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.rfind","name":"rfind","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rfind","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.rfind","name":"rfind","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rfind","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rfind","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rfind","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rfind","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"rindex":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.strings.rindex","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.rindex","name":"rindex","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rindex","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.rindex","name":"rindex","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rindex","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.rindex","name":"rindex","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rindex","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.rindex","name":"rindex","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rindex","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.rindex","name":"rindex","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rindex","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.rindex","name":"rindex","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rindex","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rindex","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rindex","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","sub","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rindex","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"rjust":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.strings.rjust","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.rjust","name":"rjust","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rjust","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.rjust","name":"rjust","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rjust","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.rjust","name":"rjust","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rjust","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.rjust","name":"rjust","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rjust","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.rjust","name":"rjust","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rjust","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.rjust","name":"rjust","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rjust","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.rjust","name":"rjust","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rjust","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.rjust","name":"rjust","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rjust","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rjust","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rjust","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rjust","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","width","fillchar"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rjust","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"rpartition":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.strings.rpartition","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","sep"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.rpartition","name":"rpartition","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rpartition","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.rpartition","name":"rpartition","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rpartition","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","sep"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.rpartition","name":"rpartition","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rpartition","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.rpartition","name":"rpartition","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rpartition","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","sep"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.rpartition","name":"rpartition","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rpartition","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.rpartition","name":"rpartition","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rpartition","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","sep"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.rpartition","name":"rpartition","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rpartition","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.rpartition","name":"rpartition","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rpartition","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rpartition","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rpartition","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rpartition","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","sep"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rpartition","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"rstrip":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.strings.rstrip","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","chars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.rstrip","name":"rstrip","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.rstrip","name":"rstrip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","chars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.rstrip","name":"rstrip","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.rstrip","name":"rstrip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","chars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.rstrip","name":"rstrip","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.rstrip","name":"rstrip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","chars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.rstrip","name":"rstrip","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.rstrip","name":"rstrip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rstrip","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"slice":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.strings.slice","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":[null,null,null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.slice","name":"slice","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":[null,null,null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"slice","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.slice","name":"slice","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":[null,null,null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"slice","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":[null,null,null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.slice","name":"slice","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":[null,null,null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"slice","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.slice","name":"slice","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":[null,null,null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"slice","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":[null,null,null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.slice","name":"slice","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":[null,null,null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"slice","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.slice","name":"slice","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":[null,null,null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"slice","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":[null,null,null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.slice","name":"slice","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":[null,null,null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"slice","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.slice","name":"slice","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":[null,null,null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"slice","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":[null,null,null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"slice","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":[null,null,null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"slice","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":[null,null,null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"slice","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":[null,null,null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"slice","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"startswith":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.strings.startswith","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","prefix","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.startswith","name":"startswith","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","prefix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"startswith","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.startswith","name":"startswith","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","prefix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"startswith","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","prefix","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.startswith","name":"startswith","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","prefix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"startswith","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.startswith","name":"startswith","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","prefix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"startswith","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","prefix","start","end"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.startswith","name":"startswith","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","prefix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"startswith","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.startswith","name":"startswith","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","prefix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"startswith","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","prefix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"startswith","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","prefix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"startswith","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","prefix","start","end"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"startswith","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"str_len":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._core.strings.str_len","name":"str_len","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"str_len","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"strip":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.strings.strip","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","chars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.strip","name":"strip","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.strip","name":"strip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","chars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.strip","name":"strip","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.strip","name":"strip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","chars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.strip","name":"strip","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strip","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.strip","name":"strip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strip","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","chars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.strip","name":"strip","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strip","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.strip","name":"strip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strip","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strip","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","chars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strip","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"swapcase":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.strings.swapcase","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.swapcase","name":"swapcase","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"swapcase","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.swapcase","name":"swapcase","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"swapcase","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.swapcase","name":"swapcase","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"swapcase","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.swapcase","name":"swapcase","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"swapcase","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.swapcase","name":"swapcase","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"swapcase","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.swapcase","name":"swapcase","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"swapcase","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.swapcase","name":"swapcase","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"swapcase","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.swapcase","name":"swapcase","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"swapcase","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"swapcase","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"swapcase","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"swapcase","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"swapcase","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"title":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.strings.title","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.title","name":"title","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"title","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.title","name":"title","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"title","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.title","name":"title","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"title","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.title","name":"title","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"title","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.title","name":"title","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"title","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.title","name":"title","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"title","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.title","name":"title","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"title","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.title","name":"title","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"title","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"title","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"title","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"title","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"title","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"translate":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.strings.translate","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","table","deletechars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.translate","name":"translate","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","table","deletechars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"translate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.translate","name":"translate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","table","deletechars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"translate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","table","deletechars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.translate","name":"translate","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","table","deletechars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"translate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.translate","name":"translate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","table","deletechars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"translate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","table","deletechars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.translate","name":"translate","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","table","deletechars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"translate","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.translate","name":"translate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","table","deletechars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"translate","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","table","deletechars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.translate","name":"translate","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","table","deletechars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"translate","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.translate","name":"translate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","table","deletechars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"translate","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","table","deletechars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"translate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","table","deletechars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"translate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","table","deletechars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"translate","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","table","deletechars"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"translate","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"upper":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.strings.upper","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.upper","name":"upper","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"upper","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.upper","name":"upper","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"upper","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.upper","name":"upper","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"upper","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.upper","name":"upper","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"upper","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.upper","name":"upper","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"upper","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.upper","name":"upper","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"upper","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.upper","name":"upper","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"upper","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.upper","name":"upper","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"upper","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"upper","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"upper","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"upper","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"upper","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"zfill":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._core.strings.zfill","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","width"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.zfill","name":"zfill","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","width"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zfill","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.zfill","name":"zfill","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","width"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zfill","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","width"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.zfill","name":"zfill","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","width"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zfill","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.zfill","name":"zfill","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","width"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zfill","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","width"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.zfill","name":"zfill","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","width"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zfill","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.zfill","name":"zfill","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","width"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zfill","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","width"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy._core.strings.zfill","name":"zfill","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","width"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zfill","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._core.strings.zfill","name":"zfill","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","width"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zfill","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","width"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zfill","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","width"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zfill","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","width"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zfill","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","width"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zfill","ret_type":{".class":"AnyType","missing_import_name":"numpy._core.strings.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_core/strings.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/strings.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/strings.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..48365e90a97474445750352207e0581cfb17b949 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_core/strings.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[4,1,3,1,1,1,1,1],"dep_prios":[5,5,10,5,30,30,30,30],"dependencies":["numpy._typing","typing","numpy","builtins","_frozen_importlib","abc","numpy._typing._array_like","numpy.dtypes"],"hash":"b62ec8377e85bd39fb2e4f81e855bcafea0c3bbd","id":"numpy._core.strings","ignore_all":true,"interface_hash":"25fdc55b3322b2d8447b2497f1d0c86e47c75aa6","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_core/strings.pyi","plugin_data":null,"size":13502,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..dfe4098acd0ff9fa42973f20f1f7336831f8575d --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy._typing","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.ArrayLike","kind":"Gdef"},"DTypeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like.DTypeLike","kind":"Gdef"},"NBitBase":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nbit_base.NBitBase","kind":"Gdef"},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef"},"_128Bit":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nbit_base._128Bit","kind":"Gdef"},"_16Bit":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nbit_base._16Bit","kind":"Gdef"},"_32Bit":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nbit_base._32Bit","kind":"Gdef"},"_64Bit":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nbit_base._64Bit","kind":"Gdef"},"_8Bit":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nbit_base._8Bit","kind":"Gdef"},"_96Bit":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nbit_base._96Bit","kind":"Gdef"},"_AnyShape":{".class":"SymbolTableNode","cross_ref":"numpy._typing._shape._AnyShape","kind":"Gdef"},"_ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLike","kind":"Gdef"},"_ArrayLikeAnyString_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeAnyString_co","kind":"Gdef"},"_ArrayLikeBool_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeBool_co","kind":"Gdef"},"_ArrayLikeBytes_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeBytes_co","kind":"Gdef"},"_ArrayLikeComplex128_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeComplex128_co","kind":"Gdef"},"_ArrayLikeComplex_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeComplex_co","kind":"Gdef"},"_ArrayLikeDT64_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeDT64_co","kind":"Gdef"},"_ArrayLikeFloat64_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeFloat64_co","kind":"Gdef"},"_ArrayLikeFloat_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeFloat_co","kind":"Gdef"},"_ArrayLikeInt":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeInt","kind":"Gdef"},"_ArrayLikeInt_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeInt_co","kind":"Gdef"},"_ArrayLikeNumber_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeNumber_co","kind":"Gdef"},"_ArrayLikeObject_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeObject_co","kind":"Gdef"},"_ArrayLikeStr_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeStr_co","kind":"Gdef"},"_ArrayLikeString_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeString_co","kind":"Gdef"},"_ArrayLikeTD64_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeTD64_co","kind":"Gdef"},"_ArrayLikeUInt_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeUInt_co","kind":"Gdef"},"_ArrayLikeVoid_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeVoid_co","kind":"Gdef"},"_BoolCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._BoolCodes","kind":"Gdef"},"_BoolLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._BoolLike_co","kind":"Gdef"},"_ByteCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._ByteCodes","kind":"Gdef"},"_BytesCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._BytesCodes","kind":"Gdef"},"_CDoubleCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._CDoubleCodes","kind":"Gdef"},"_CLongDoubleCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._CLongDoubleCodes","kind":"Gdef"},"_CSingleCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._CSingleCodes","kind":"Gdef"},"_CharLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._CharLike_co","kind":"Gdef"},"_CharacterCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._CharacterCodes","kind":"Gdef"},"_Complex128Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._Complex128Codes","kind":"Gdef"},"_Complex64Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._Complex64Codes","kind":"Gdef"},"_ComplexFloatingCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._ComplexFloatingCodes","kind":"Gdef"},"_ComplexLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._ComplexLike_co","kind":"Gdef"},"_DT64Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._DT64Codes","kind":"Gdef"},"_DTypeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._DTypeLike","kind":"Gdef"},"_DTypeLikeBool":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._DTypeLikeBool","kind":"Gdef"},"_DTypeLikeBytes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._DTypeLikeBytes","kind":"Gdef"},"_DTypeLikeComplex":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._DTypeLikeComplex","kind":"Gdef"},"_DTypeLikeComplex_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._DTypeLikeComplex_co","kind":"Gdef"},"_DTypeLikeDT64":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._DTypeLikeDT64","kind":"Gdef"},"_DTypeLikeFloat":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._DTypeLikeFloat","kind":"Gdef"},"_DTypeLikeInt":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._DTypeLikeInt","kind":"Gdef"},"_DTypeLikeObject":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._DTypeLikeObject","kind":"Gdef"},"_DTypeLikeStr":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._DTypeLikeStr","kind":"Gdef"},"_DTypeLikeTD64":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._DTypeLikeTD64","kind":"Gdef"},"_DTypeLikeUInt":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._DTypeLikeUInt","kind":"Gdef"},"_DTypeLikeVoid":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._DTypeLikeVoid","kind":"Gdef"},"_DoubleCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._DoubleCodes","kind":"Gdef"},"_FiniteNestedSequence":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._FiniteNestedSequence","kind":"Gdef"},"_FlexibleCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._FlexibleCodes","kind":"Gdef"},"_Float16Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._Float16Codes","kind":"Gdef"},"_Float32Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._Float32Codes","kind":"Gdef"},"_Float64Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._Float64Codes","kind":"Gdef"},"_FloatLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._FloatLike_co","kind":"Gdef"},"_FloatingCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._FloatingCodes","kind":"Gdef"},"_GUFunc_Nin2_Nout1":{".class":"SymbolTableNode","cross_ref":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","kind":"Gdef"},"_GenericCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._GenericCodes","kind":"Gdef"},"_HalfCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._HalfCodes","kind":"Gdef"},"_InexactCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._InexactCodes","kind":"Gdef"},"_Int16Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._Int16Codes","kind":"Gdef"},"_Int32Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._Int32Codes","kind":"Gdef"},"_Int64Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._Int64Codes","kind":"Gdef"},"_Int8Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._Int8Codes","kind":"Gdef"},"_IntCCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._IntCCodes","kind":"Gdef"},"_IntCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._IntCodes","kind":"Gdef"},"_IntLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._IntLike_co","kind":"Gdef"},"_IntPCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._IntPCodes","kind":"Gdef"},"_IntegerCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._IntegerCodes","kind":"Gdef"},"_LongCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._LongCodes","kind":"Gdef"},"_LongDoubleCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._LongDoubleCodes","kind":"Gdef"},"_LongLongCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._LongLongCodes","kind":"Gdef"},"_NBitByte":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nbit._NBitByte","kind":"Gdef"},"_NBitDouble":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nbit._NBitDouble","kind":"Gdef"},"_NBitHalf":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nbit._NBitHalf","kind":"Gdef"},"_NBitInt":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nbit._NBitInt","kind":"Gdef"},"_NBitIntC":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nbit._NBitIntC","kind":"Gdef"},"_NBitIntP":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nbit._NBitIntP","kind":"Gdef"},"_NBitLong":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nbit._NBitLong","kind":"Gdef"},"_NBitLongDouble":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nbit._NBitLongDouble","kind":"Gdef"},"_NBitLongLong":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nbit._NBitLongLong","kind":"Gdef"},"_NBitShort":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nbit._NBitShort","kind":"Gdef"},"_NBitSingle":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nbit._NBitSingle","kind":"Gdef"},"_NestedSequence":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nested_sequence._NestedSequence","kind":"Gdef"},"_NumberCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._NumberCodes","kind":"Gdef"},"_NumberLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._NumberLike_co","kind":"Gdef"},"_ObjectCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._ObjectCodes","kind":"Gdef"},"_ScalarLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._ScalarLike_co","kind":"Gdef"},"_Shape":{".class":"SymbolTableNode","cross_ref":"numpy._typing._shape._Shape","kind":"Gdef"},"_ShapeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._shape._ShapeLike","kind":"Gdef"},"_ShortCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._ShortCodes","kind":"Gdef"},"_SignedIntegerCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._SignedIntegerCodes","kind":"Gdef"},"_SingleCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._SingleCodes","kind":"Gdef"},"_StrCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._StrCodes","kind":"Gdef"},"_StringCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._StringCodes","kind":"Gdef"},"_SupportsArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._SupportsArray","kind":"Gdef"},"_SupportsArrayFunc":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._SupportsArrayFunc","kind":"Gdef"},"_SupportsDType":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._SupportsDType","kind":"Gdef"},"_TD64Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._TD64Codes","kind":"Gdef"},"_TD64Like_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._TD64Like_co","kind":"Gdef"},"_UByteCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._UByteCodes","kind":"Gdef"},"_UFunc_Nin1_Nout1":{".class":"SymbolTableNode","cross_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout1","kind":"Gdef"},"_UFunc_Nin1_Nout2":{".class":"SymbolTableNode","cross_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout2","kind":"Gdef"},"_UFunc_Nin2_Nout1":{".class":"SymbolTableNode","cross_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1","kind":"Gdef"},"_UFunc_Nin2_Nout2":{".class":"SymbolTableNode","cross_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout2","kind":"Gdef"},"_UInt16Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._UInt16Codes","kind":"Gdef"},"_UInt32Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._UInt32Codes","kind":"Gdef"},"_UInt64Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._UInt64Codes","kind":"Gdef"},"_UInt8Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._UInt8Codes","kind":"Gdef"},"_UIntCCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._UIntCCodes","kind":"Gdef"},"_UIntCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._UIntCodes","kind":"Gdef"},"_UIntLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._UIntLike_co","kind":"Gdef"},"_UIntPCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._UIntPCodes","kind":"Gdef"},"_ULongCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._ULongCodes","kind":"Gdef"},"_ULongLongCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._ULongLongCodes","kind":"Gdef"},"_UShortCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._UShortCodes","kind":"Gdef"},"_UnsignedIntegerCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._UnsignedIntegerCodes","kind":"Gdef"},"_VoidCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._VoidCodes","kind":"Gdef"},"_VoidDTypeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._VoidDTypeLike","kind":"Gdef"},"_VoidLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._VoidLike_co","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_typing/__init__.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..089ed283069ab9e05cb2c88e192e6e378ee8633a --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[3,28,82,100,113,124,127,139,144,1,1,1,1],"dep_prios":[5,5,5,5,5,5,5,5,5,5,30,30,30],"dependencies":["numpy._typing._array_like","numpy._typing._char_codes","numpy._typing._dtype_like","numpy._typing._nbit","numpy._typing._nbit_base","numpy._typing._nested_sequence","numpy._typing._scalars","numpy._typing._shape","numpy._typing._ufunc","builtins","_frozen_importlib","abc","typing"],"hash":"13ca36804ad9a151d43389f0591f53771f259fa3","id":"numpy._typing","ignore_all":true,"interface_hash":"436033d218e5a0495de051562e14f2ecf84851fe","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_typing/__init__.py","plugin_data":null,"size":7188,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_add_docstring.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_add_docstring.data.json new file mode 100644 index 0000000000000000000000000000000000000000..7d2d29cb4a2835395cb95a52b00c9f27f5cae5b0 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_add_docstring.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy._typing._add_docstring","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._add_docstring.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._add_docstring.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._add_docstring.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._add_docstring.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._add_docstring.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._add_docstring.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_docstrings":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy._typing._add_docstring._docstrings","name":"_docstrings","setter_type":null,"type":"builtins.str"}},"_docstrings_list":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","invalid_partial_type","has_explicit_value"],"fullname":"numpy._typing._add_docstring._docstrings_list","name":"_docstrings_list","setter_type":null,"type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"builtins.list"}}},"_parse_docstrings":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._typing._add_docstring._parse_docstrings","name":"_parse_docstrings","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_parse_docstrings","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"add_newdoc":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["name","value","doc"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy._typing._add_docstring.add_newdoc","name":"add_newdoc","original_first_arg":"name","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["name","value","doc"],"arg_types":["builtins.str","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add_newdoc","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef"},"textwrap":{".class":"SymbolTableNode","cross_ref":"textwrap","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_typing/_add_docstring.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_add_docstring.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_add_docstring.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..38c219f92ceb83bf1b43d3b7b2c871c3b5170236 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_add_docstring.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[6,3,4,1,1,1,1],"dep_prios":[5,10,10,5,30,30,30],"dependencies":["numpy._typing._array_like","re","textwrap","builtins","_frozen_importlib","abc","typing"],"hash":"b6703620519e9ffd263d054ad94e0aea9dffec1a","id":"numpy._typing._add_docstring","ignore_all":true,"interface_hash":"cf94bfc85d0e29e363dc80f0975b37cb152fdd99","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_typing/_add_docstring.py","plugin_data":null,"size":3999,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_array_like.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_array_like.data.json new file mode 100644 index 0000000000000000000000000000000000000000..f12db8b954925622990f45d6266ce71706791c47 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_array_like.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy._typing._array_like","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"ArrayLike":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._array_like.ArrayLike","name":"ArrayLike","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"Collection":{".class":"SymbolTableNode","cross_ref":"typing.Collection","kind":"Gdef"},"NDArray":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._array_like.NDArray","name":"NDArray","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"Protocol":{".class":"SymbolTableNode","cross_ref":"typing.Protocol","kind":"Gdef"},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef"},"StringDType":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"numpy._typing._array_like.StringDType","line":13,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.dtypes.Never","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtypes.StringDType"}}},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy._typing._array_like.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef"},"_32Bit":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nbit_base._32Bit","kind":"Gdef"},"_64Bit":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nbit_base._64Bit","kind":"Gdef"},"_AnyShape":{".class":"SymbolTableNode","cross_ref":"numpy._typing._shape._AnyShape","kind":"Gdef"},"_ArrayLike":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._array_like._ArrayLike","name":"_ArrayLike","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"_ArrayLikeAnyString_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._array_like._ArrayLikeAnyString_co","name":"_ArrayLikeAnyString_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"_ArrayLikeBool_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._array_like._ArrayLikeBool_co","name":"_ArrayLikeBool_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"_ArrayLikeBytes_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._array_like._ArrayLikeBytes_co","name":"_ArrayLikeBytes_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"_ArrayLikeComplex128_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._array_like._ArrayLikeComplex128_co","name":"_ArrayLikeComplex128_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"_ArrayLikeComplex_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._array_like._ArrayLikeComplex_co","name":"_ArrayLikeComplex_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"_ArrayLikeDT64_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._array_like._ArrayLikeDT64_co","name":"_ArrayLikeDT64_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"_ArrayLikeFloat64_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._array_like._ArrayLikeFloat64_co","name":"_ArrayLikeFloat64_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"_ArrayLikeFloat_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._array_like._ArrayLikeFloat_co","name":"_ArrayLikeFloat_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"_ArrayLikeInt":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._array_like._ArrayLikeInt","name":"_ArrayLikeInt","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"_ArrayLikeInt_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._array_like._ArrayLikeInt_co","name":"_ArrayLikeInt_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"_ArrayLikeNumber_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._array_like._ArrayLikeNumber_co","name":"_ArrayLikeNumber_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"_ArrayLikeObject_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._array_like._ArrayLikeObject_co","name":"_ArrayLikeObject_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"_ArrayLikeStr_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._array_like._ArrayLikeStr_co","name":"_ArrayLikeStr_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"_ArrayLikeString_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._array_like._ArrayLikeString_co","name":"_ArrayLikeString_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"_ArrayLikeTD64_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._array_like._ArrayLikeTD64_co","name":"_ArrayLikeTD64_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"_ArrayLikeUInt_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._array_like._ArrayLikeUInt_co","name":"_ArrayLikeUInt_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"_ArrayLikeVoid_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._array_like._ArrayLikeVoid_co","name":"_ArrayLikeVoid_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"_Buffer":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[["__buffer__",2]],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._typing._array_like._Buffer","name":"_Buffer","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_abstract","is_protocol","runtime_protocol"],"fullname":"numpy._typing._array_like._Buffer","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy._typing._array_like","mro":["numpy._typing._array_like._Buffer","builtins.object"],"names":{".class":"SymbolTable","__buffer__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_body","is_trivial_self"],"fullname":"numpy._typing._array_like._Buffer.__buffer__","name":"__buffer__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy._typing._array_like._Buffer","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__buffer__ of _Buffer","ret_type":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.memoryview"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._array_like._Buffer.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy._typing._array_like._Buffer","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_DTypeT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._array_like._DTypeT","name":"_DTypeT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}},"_DTypeT_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._array_like._DTypeT_co","name":"_DTypeT_co","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}},"_DualArrayLike":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._array_like._DualArrayLike","name":"_DualArrayLike","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"_FiniteNestedSequence":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._array_like._FiniteNestedSequence","name":"_FiniteNestedSequence","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"_NestedSequence":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nested_sequence._NestedSequence","kind":"Gdef"},"_ScalarT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._array_like._ScalarT","name":"_ScalarT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},"_SupportsArray":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[["__array__",2]],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._typing._array_like._SupportsArray","name":"_SupportsArray","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._array_like._DTypeT_co","id":1,"name":"_DTypeT_co","namespace":"numpy._typing._array_like._SupportsArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":["is_abstract","is_protocol","runtime_protocol"],"fullname":"numpy._typing._array_like._SupportsArray","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy._typing._array_like","mro":["numpy._typing._array_like._SupportsArray","builtins.object"],"names":{".class":"SymbolTable","__array__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_body","is_trivial_self"],"fullname":"numpy._typing._array_like._SupportsArray.__array__","name":"__array__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._array_like._DTypeT_co","id":1,"name":"_DTypeT_co","namespace":"numpy._typing._array_like._SupportsArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._array_like._SupportsArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__array__ of _SupportsArray","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._array_like._DTypeT_co","id":1,"name":"_DTypeT_co","namespace":"numpy._typing._array_like._SupportsArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._array_like._SupportsArray.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._array_like._DTypeT_co","id":1,"name":"_DTypeT_co","namespace":"numpy._typing._array_like._SupportsArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._array_like._SupportsArray"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_DTypeT_co"],"typeddict_type":null}},"_SupportsArrayFunc":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[["__array_function__",2]],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._typing._array_like._SupportsArrayFunc","name":"_SupportsArrayFunc","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_abstract","is_protocol","runtime_protocol"],"fullname":"numpy._typing._array_like._SupportsArrayFunc","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy._typing._array_like","mro":["numpy._typing._array_like._SupportsArrayFunc","builtins.object"],"names":{".class":"SymbolTable","__array_function__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0,0,0,0,0],"arg_names":["self","func","types","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_body","is_trivial_self"],"fullname":"numpy._typing._array_like._SupportsArrayFunc.__array_function__","name":"__array_function__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":["self","func","types","args","kwargs"],"arg_types":["numpy._typing._array_like._SupportsArrayFunc",{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"Instance","args":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"extra_attrs":null,"type_ref":"typing.Collection"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__array_function__ of _SupportsArrayFunc","ret_type":"builtins.object","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._array_like._SupportsArrayFunc.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy._typing._array_like._SupportsArrayFunc","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_T":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._array_like._T","name":"_T","upper_bound":"builtins.object","values":[],"variance":0}},"__Complex128_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._array_like.__Complex128_co","name":"__Complex128_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"__Float64_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._array_like.__Float64_co","name":"__Float64_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._array_like.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._array_like.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._array_like.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._array_like.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._array_like.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._array_like.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"dtype":{".class":"SymbolTableNode","cross_ref":"numpy.dtype","kind":"Gdef"},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef"},"runtime_checkable":{".class":"SymbolTableNode","cross_ref":"typing.runtime_checkable","kind":"Gdef"},"sys":{".class":"SymbolTableNode","cross_ref":"sys","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_typing/_array_like.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_array_like.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_array_like.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..f5ed1b9f1e48de8bc7961eb77f454c520be977d6 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_array_like.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[8,9,10,2,1,3,5,1,1,1,1,1,1,1,1,1,1],"dep_prios":[5,5,5,5,10,5,5,5,30,30,30,30,30,30,30,30,30],"dependencies":["numpy._typing._nbit_base","numpy._typing._nested_sequence","numpy._typing._shape","collections.abc","sys","typing","numpy","builtins","_ctypes","_frozen_importlib","_typeshed","abc","ctypes","datetime","numpy.dtypes","types","typing_extensions"],"hash":"35e839a3943d5a99edde8dfbd1d06c8fa87d58e9","id":"numpy._typing._array_like","ignore_all":true,"interface_hash":"174f8b3018ff707d23547a2b3902fc0fc16df645","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_typing/_array_like.py","plugin_data":null,"size":4188,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_char_codes.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_char_codes.data.json new file mode 100644 index 0000000000000000000000000000000000000000..3f007e47b6cbf9ca5e82199c7e582fd5c789dc11 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_char_codes.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy._typing._char_codes","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"_BoolCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._BoolCodes","line":3,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"bool"},{".class":"LiteralType","fallback":"builtins.str","value":"bool_"},{".class":"LiteralType","fallback":"builtins.str","value":"?"},{".class":"LiteralType","fallback":"builtins.str","value":"|?"},{".class":"LiteralType","fallback":"builtins.str","value":"=?"},{".class":"LiteralType","fallback":"builtins.str","value":"?"},{".class":"LiteralType","fallback":"builtins.str","value":"b1"},{".class":"LiteralType","fallback":"builtins.str","value":"|b1"},{".class":"LiteralType","fallback":"builtins.str","value":"=b1"},{".class":"LiteralType","fallback":"builtins.str","value":"b1"}],"uses_pep604_syntax":false}}},"_ByteCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._ByteCodes","line":26,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"byte"},{".class":"LiteralType","fallback":"builtins.str","value":"b"},{".class":"LiteralType","fallback":"builtins.str","value":"|b"},{".class":"LiteralType","fallback":"builtins.str","value":"=b"},{".class":"LiteralType","fallback":"builtins.str","value":"b"}],"uses_pep604_syntax":false}}},"_BytesCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._BytesCodes","line":52,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"bytes"},{".class":"LiteralType","fallback":"builtins.str","value":"bytes_"},{".class":"LiteralType","fallback":"builtins.str","value":"S"},{".class":"LiteralType","fallback":"builtins.str","value":"|S"},{".class":"LiteralType","fallback":"builtins.str","value":"=S"},{".class":"LiteralType","fallback":"builtins.str","value":"S"}],"uses_pep604_syntax":false}}},"_CDoubleCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._CDoubleCodes","line":48,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cdouble"},{".class":"LiteralType","fallback":"builtins.str","value":"complex"},{".class":"LiteralType","fallback":"builtins.str","value":"D"},{".class":"LiteralType","fallback":"builtins.str","value":"|D"},{".class":"LiteralType","fallback":"builtins.str","value":"=D"},{".class":"LiteralType","fallback":"builtins.str","value":"D"}],"uses_pep604_syntax":false}}},"_CLongDoubleCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._CLongDoubleCodes","line":49,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"clongdouble"},{".class":"LiteralType","fallback":"builtins.str","value":"G"},{".class":"LiteralType","fallback":"builtins.str","value":"|G"},{".class":"LiteralType","fallback":"builtins.str","value":"=G"},{".class":"LiteralType","fallback":"builtins.str","value":"G"}],"uses_pep604_syntax":false}}},"_CSingleCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._CSingleCodes","line":47,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"csingle"},{".class":"LiteralType","fallback":"builtins.str","value":"F"},{".class":"LiteralType","fallback":"builtins.str","value":"|F"},{".class":"LiteralType","fallback":"builtins.str","value":"=F"},{".class":"LiteralType","fallback":"builtins.str","value":"F"}],"uses_pep604_syntax":false}}},"_CharacterCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._CharacterCodes","line":201,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"str"},{".class":"LiteralType","fallback":"builtins.str","value":"str_"},{".class":"LiteralType","fallback":"builtins.str","value":"unicode"},{".class":"LiteralType","fallback":"builtins.str","value":"U"},{".class":"LiteralType","fallback":"builtins.str","value":"|U"},{".class":"LiteralType","fallback":"builtins.str","value":"=U"},{".class":"LiteralType","fallback":"builtins.str","value":"U"},{".class":"LiteralType","fallback":"builtins.str","value":"bytes"},{".class":"LiteralType","fallback":"builtins.str","value":"bytes_"},{".class":"LiteralType","fallback":"builtins.str","value":"S"},{".class":"LiteralType","fallback":"builtins.str","value":"|S"},{".class":"LiteralType","fallback":"builtins.str","value":"=S"},{".class":"LiteralType","fallback":"builtins.str","value":"S"}],"uses_pep604_syntax":false}}},"_Complex128Codes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._Complex128Codes","line":24,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"complex128"},{".class":"LiteralType","fallback":"builtins.str","value":"c16"},{".class":"LiteralType","fallback":"builtins.str","value":"|c16"},{".class":"LiteralType","fallback":"builtins.str","value":"=c16"},{".class":"LiteralType","fallback":"builtins.str","value":"c16"}],"uses_pep604_syntax":false}}},"_Complex64Codes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._Complex64Codes","line":23,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"complex64"},{".class":"LiteralType","fallback":"builtins.str","value":"c8"},{".class":"LiteralType","fallback":"builtins.str","value":"|c8"},{".class":"LiteralType","fallback":"builtins.str","value":"=c8"},{".class":"LiteralType","fallback":"builtins.str","value":"c8"}],"uses_pep604_syntax":false}}},"_ComplexFloatingCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._ComplexFloatingCodes","line":190,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"complex64"},{".class":"LiteralType","fallback":"builtins.str","value":"c8"},{".class":"LiteralType","fallback":"builtins.str","value":"|c8"},{".class":"LiteralType","fallback":"builtins.str","value":"=c8"},{".class":"LiteralType","fallback":"builtins.str","value":"c8"},{".class":"LiteralType","fallback":"builtins.str","value":"complex128"},{".class":"LiteralType","fallback":"builtins.str","value":"c16"},{".class":"LiteralType","fallback":"builtins.str","value":"|c16"},{".class":"LiteralType","fallback":"builtins.str","value":"=c16"},{".class":"LiteralType","fallback":"builtins.str","value":"c16"},{".class":"LiteralType","fallback":"builtins.str","value":"csingle"},{".class":"LiteralType","fallback":"builtins.str","value":"F"},{".class":"LiteralType","fallback":"builtins.str","value":"|F"},{".class":"LiteralType","fallback":"builtins.str","value":"=F"},{".class":"LiteralType","fallback":"builtins.str","value":"F"},{".class":"LiteralType","fallback":"builtins.str","value":"cdouble"},{".class":"LiteralType","fallback":"builtins.str","value":"complex"},{".class":"LiteralType","fallback":"builtins.str","value":"D"},{".class":"LiteralType","fallback":"builtins.str","value":"|D"},{".class":"LiteralType","fallback":"builtins.str","value":"=D"},{".class":"LiteralType","fallback":"builtins.str","value":"D"},{".class":"LiteralType","fallback":"builtins.str","value":"clongdouble"},{".class":"LiteralType","fallback":"builtins.str","value":"G"},{".class":"LiteralType","fallback":"builtins.str","value":"|G"},{".class":"LiteralType","fallback":"builtins.str","value":"=G"},{".class":"LiteralType","fallback":"builtins.str","value":"G"}],"uses_pep604_syntax":false}}},"_DT64Codes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._DT64Codes","line":56,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"datetime64"},{".class":"LiteralType","fallback":"builtins.str","value":"|datetime64"},{".class":"LiteralType","fallback":"builtins.str","value":"=datetime64"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[Y]"},{".class":"LiteralType","fallback":"builtins.str","value":"|datetime64[Y]"},{".class":"LiteralType","fallback":"builtins.str","value":"=datetime64[Y]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[Y]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[M]"},{".class":"LiteralType","fallback":"builtins.str","value":"|datetime64[M]"},{".class":"LiteralType","fallback":"builtins.str","value":"=datetime64[M]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[M]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[W]"},{".class":"LiteralType","fallback":"builtins.str","value":"|datetime64[W]"},{".class":"LiteralType","fallback":"builtins.str","value":"=datetime64[W]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[W]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[D]"},{".class":"LiteralType","fallback":"builtins.str","value":"|datetime64[D]"},{".class":"LiteralType","fallback":"builtins.str","value":"=datetime64[D]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[D]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[h]"},{".class":"LiteralType","fallback":"builtins.str","value":"|datetime64[h]"},{".class":"LiteralType","fallback":"builtins.str","value":"=datetime64[h]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[h]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[m]"},{".class":"LiteralType","fallback":"builtins.str","value":"|datetime64[m]"},{".class":"LiteralType","fallback":"builtins.str","value":"=datetime64[m]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[m]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[s]"},{".class":"LiteralType","fallback":"builtins.str","value":"|datetime64[s]"},{".class":"LiteralType","fallback":"builtins.str","value":"=datetime64[s]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[s]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[ms]"},{".class":"LiteralType","fallback":"builtins.str","value":"|datetime64[ms]"},{".class":"LiteralType","fallback":"builtins.str","value":"=datetime64[ms]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[ms]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[us]"},{".class":"LiteralType","fallback":"builtins.str","value":"|datetime64[us]"},{".class":"LiteralType","fallback":"builtins.str","value":"=datetime64[us]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[us]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[ns]"},{".class":"LiteralType","fallback":"builtins.str","value":"|datetime64[ns]"},{".class":"LiteralType","fallback":"builtins.str","value":"=datetime64[ns]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[ns]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[ps]"},{".class":"LiteralType","fallback":"builtins.str","value":"|datetime64[ps]"},{".class":"LiteralType","fallback":"builtins.str","value":"=datetime64[ps]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[ps]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[fs]"},{".class":"LiteralType","fallback":"builtins.str","value":"|datetime64[fs]"},{".class":"LiteralType","fallback":"builtins.str","value":"=datetime64[fs]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[fs]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[as]"},{".class":"LiteralType","fallback":"builtins.str","value":"|datetime64[as]"},{".class":"LiteralType","fallback":"builtins.str","value":"=datetime64[as]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[as]"},{".class":"LiteralType","fallback":"builtins.str","value":"M"},{".class":"LiteralType","fallback":"builtins.str","value":"|M"},{".class":"LiteralType","fallback":"builtins.str","value":"=M"},{".class":"LiteralType","fallback":"builtins.str","value":"M"},{".class":"LiteralType","fallback":"builtins.str","value":"M8"},{".class":"LiteralType","fallback":"builtins.str","value":"|M8"},{".class":"LiteralType","fallback":"builtins.str","value":"=M8"},{".class":"LiteralType","fallback":"builtins.str","value":"M8"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[Y]"},{".class":"LiteralType","fallback":"builtins.str","value":"|M8[Y]"},{".class":"LiteralType","fallback":"builtins.str","value":"=M8[Y]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[Y]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[M]"},{".class":"LiteralType","fallback":"builtins.str","value":"|M8[M]"},{".class":"LiteralType","fallback":"builtins.str","value":"=M8[M]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[M]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[W]"},{".class":"LiteralType","fallback":"builtins.str","value":"|M8[W]"},{".class":"LiteralType","fallback":"builtins.str","value":"=M8[W]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[W]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[D]"},{".class":"LiteralType","fallback":"builtins.str","value":"|M8[D]"},{".class":"LiteralType","fallback":"builtins.str","value":"=M8[D]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[D]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[h]"},{".class":"LiteralType","fallback":"builtins.str","value":"|M8[h]"},{".class":"LiteralType","fallback":"builtins.str","value":"=M8[h]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[h]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[m]"},{".class":"LiteralType","fallback":"builtins.str","value":"|M8[m]"},{".class":"LiteralType","fallback":"builtins.str","value":"=M8[m]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[m]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[s]"},{".class":"LiteralType","fallback":"builtins.str","value":"|M8[s]"},{".class":"LiteralType","fallback":"builtins.str","value":"=M8[s]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[s]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[ms]"},{".class":"LiteralType","fallback":"builtins.str","value":"|M8[ms]"},{".class":"LiteralType","fallback":"builtins.str","value":"=M8[ms]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[ms]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[us]"},{".class":"LiteralType","fallback":"builtins.str","value":"|M8[us]"},{".class":"LiteralType","fallback":"builtins.str","value":"=M8[us]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[us]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[ns]"},{".class":"LiteralType","fallback":"builtins.str","value":"|M8[ns]"},{".class":"LiteralType","fallback":"builtins.str","value":"=M8[ns]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[ns]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[ps]"},{".class":"LiteralType","fallback":"builtins.str","value":"|M8[ps]"},{".class":"LiteralType","fallback":"builtins.str","value":"=M8[ps]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[ps]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[fs]"},{".class":"LiteralType","fallback":"builtins.str","value":"|M8[fs]"},{".class":"LiteralType","fallback":"builtins.str","value":"=M8[fs]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[fs]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[as]"},{".class":"LiteralType","fallback":"builtins.str","value":"|M8[as]"},{".class":"LiteralType","fallback":"builtins.str","value":"=M8[as]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[as]"}],"uses_pep604_syntax":false}}},"_DoubleCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._DoubleCodes","line":44,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"double"},{".class":"LiteralType","fallback":"builtins.str","value":"float"},{".class":"LiteralType","fallback":"builtins.str","value":"d"},{".class":"LiteralType","fallback":"builtins.str","value":"|d"},{".class":"LiteralType","fallback":"builtins.str","value":"=d"},{".class":"LiteralType","fallback":"builtins.str","value":"d"}],"uses_pep604_syntax":false}}},"_FlexibleCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._FlexibleCodes","line":202,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"void"},{".class":"LiteralType","fallback":"builtins.str","value":"V"},{".class":"LiteralType","fallback":"builtins.str","value":"|V"},{".class":"LiteralType","fallback":"builtins.str","value":"=V"},{".class":"LiteralType","fallback":"builtins.str","value":"V"},{".class":"LiteralType","fallback":"builtins.str","value":"str"},{".class":"LiteralType","fallback":"builtins.str","value":"str_"},{".class":"LiteralType","fallback":"builtins.str","value":"unicode"},{".class":"LiteralType","fallback":"builtins.str","value":"U"},{".class":"LiteralType","fallback":"builtins.str","value":"|U"},{".class":"LiteralType","fallback":"builtins.str","value":"=U"},{".class":"LiteralType","fallback":"builtins.str","value":"U"},{".class":"LiteralType","fallback":"builtins.str","value":"bytes"},{".class":"LiteralType","fallback":"builtins.str","value":"bytes_"},{".class":"LiteralType","fallback":"builtins.str","value":"S"},{".class":"LiteralType","fallback":"builtins.str","value":"|S"},{".class":"LiteralType","fallback":"builtins.str","value":"=S"},{".class":"LiteralType","fallback":"builtins.str","value":"S"}],"uses_pep604_syntax":false}}},"_Float16Codes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._Float16Codes","line":19,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"float16"},{".class":"LiteralType","fallback":"builtins.str","value":"f2"},{".class":"LiteralType","fallback":"builtins.str","value":"|f2"},{".class":"LiteralType","fallback":"builtins.str","value":"=f2"},{".class":"LiteralType","fallback":"builtins.str","value":"f2"}],"uses_pep604_syntax":false}}},"_Float32Codes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._Float32Codes","line":20,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"float32"},{".class":"LiteralType","fallback":"builtins.str","value":"f4"},{".class":"LiteralType","fallback":"builtins.str","value":"|f4"},{".class":"LiteralType","fallback":"builtins.str","value":"=f4"},{".class":"LiteralType","fallback":"builtins.str","value":"f4"}],"uses_pep604_syntax":false}}},"_Float64Codes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._Float64Codes","line":21,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"float64"},{".class":"LiteralType","fallback":"builtins.str","value":"f8"},{".class":"LiteralType","fallback":"builtins.str","value":"|f8"},{".class":"LiteralType","fallback":"builtins.str","value":"=f8"},{".class":"LiteralType","fallback":"builtins.str","value":"f8"}],"uses_pep604_syntax":false}}},"_FloatingCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._FloatingCodes","line":181,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"float16"},{".class":"LiteralType","fallback":"builtins.str","value":"f2"},{".class":"LiteralType","fallback":"builtins.str","value":"|f2"},{".class":"LiteralType","fallback":"builtins.str","value":"=f2"},{".class":"LiteralType","fallback":"builtins.str","value":"f2"},{".class":"LiteralType","fallback":"builtins.str","value":"float32"},{".class":"LiteralType","fallback":"builtins.str","value":"f4"},{".class":"LiteralType","fallback":"builtins.str","value":"|f4"},{".class":"LiteralType","fallback":"builtins.str","value":"=f4"},{".class":"LiteralType","fallback":"builtins.str","value":"f4"},{".class":"LiteralType","fallback":"builtins.str","value":"float64"},{".class":"LiteralType","fallback":"builtins.str","value":"f8"},{".class":"LiteralType","fallback":"builtins.str","value":"|f8"},{".class":"LiteralType","fallback":"builtins.str","value":"=f8"},{".class":"LiteralType","fallback":"builtins.str","value":"f8"},{".class":"LiteralType","fallback":"builtins.str","value":"half"},{".class":"LiteralType","fallback":"builtins.str","value":"e"},{".class":"LiteralType","fallback":"builtins.str","value":"|e"},{".class":"LiteralType","fallback":"builtins.str","value":"=e"},{".class":"LiteralType","fallback":"builtins.str","value":"e"},{".class":"LiteralType","fallback":"builtins.str","value":"single"},{".class":"LiteralType","fallback":"builtins.str","value":"f"},{".class":"LiteralType","fallback":"builtins.str","value":"|f"},{".class":"LiteralType","fallback":"builtins.str","value":"=f"},{".class":"LiteralType","fallback":"builtins.str","value":"f"},{".class":"LiteralType","fallback":"builtins.str","value":"double"},{".class":"LiteralType","fallback":"builtins.str","value":"float"},{".class":"LiteralType","fallback":"builtins.str","value":"d"},{".class":"LiteralType","fallback":"builtins.str","value":"|d"},{".class":"LiteralType","fallback":"builtins.str","value":"=d"},{".class":"LiteralType","fallback":"builtins.str","value":"d"},{".class":"LiteralType","fallback":"builtins.str","value":"longdouble"},{".class":"LiteralType","fallback":"builtins.str","value":"g"},{".class":"LiteralType","fallback":"builtins.str","value":"|g"},{".class":"LiteralType","fallback":"builtins.str","value":"=g"},{".class":"LiteralType","fallback":"builtins.str","value":"g"}],"uses_pep604_syntax":false}}},"_GenericCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._GenericCodes","line":204,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"bool"},{".class":"LiteralType","fallback":"builtins.str","value":"bool_"},{".class":"LiteralType","fallback":"builtins.str","value":"?"},{".class":"LiteralType","fallback":"builtins.str","value":"|?"},{".class":"LiteralType","fallback":"builtins.str","value":"=?"},{".class":"LiteralType","fallback":"builtins.str","value":"?"},{".class":"LiteralType","fallback":"builtins.str","value":"b1"},{".class":"LiteralType","fallback":"builtins.str","value":"|b1"},{".class":"LiteralType","fallback":"builtins.str","value":"=b1"},{".class":"LiteralType","fallback":"builtins.str","value":"b1"},{".class":"LiteralType","fallback":"builtins.str","value":"uint8"},{".class":"LiteralType","fallback":"builtins.str","value":"u1"},{".class":"LiteralType","fallback":"builtins.str","value":"|u1"},{".class":"LiteralType","fallback":"builtins.str","value":"=u1"},{".class":"LiteralType","fallback":"builtins.str","value":"u1"},{".class":"LiteralType","fallback":"builtins.str","value":"uint16"},{".class":"LiteralType","fallback":"builtins.str","value":"u2"},{".class":"LiteralType","fallback":"builtins.str","value":"|u2"},{".class":"LiteralType","fallback":"builtins.str","value":"=u2"},{".class":"LiteralType","fallback":"builtins.str","value":"u2"},{".class":"LiteralType","fallback":"builtins.str","value":"uint32"},{".class":"LiteralType","fallback":"builtins.str","value":"u4"},{".class":"LiteralType","fallback":"builtins.str","value":"|u4"},{".class":"LiteralType","fallback":"builtins.str","value":"=u4"},{".class":"LiteralType","fallback":"builtins.str","value":"u4"},{".class":"LiteralType","fallback":"builtins.str","value":"uint64"},{".class":"LiteralType","fallback":"builtins.str","value":"u8"},{".class":"LiteralType","fallback":"builtins.str","value":"|u8"},{".class":"LiteralType","fallback":"builtins.str","value":"=u8"},{".class":"LiteralType","fallback":"builtins.str","value":"u8"},{".class":"LiteralType","fallback":"builtins.str","value":"uintp"},{".class":"LiteralType","fallback":"builtins.str","value":"uint"},{".class":"LiteralType","fallback":"builtins.str","value":"N"},{".class":"LiteralType","fallback":"builtins.str","value":"|N"},{".class":"LiteralType","fallback":"builtins.str","value":"=N"},{".class":"LiteralType","fallback":"builtins.str","value":"N"},{".class":"LiteralType","fallback":"builtins.str","value":"ubyte"},{".class":"LiteralType","fallback":"builtins.str","value":"B"},{".class":"LiteralType","fallback":"builtins.str","value":"|B"},{".class":"LiteralType","fallback":"builtins.str","value":"=B"},{".class":"LiteralType","fallback":"builtins.str","value":"B"},{".class":"LiteralType","fallback":"builtins.str","value":"ushort"},{".class":"LiteralType","fallback":"builtins.str","value":"H"},{".class":"LiteralType","fallback":"builtins.str","value":"|H"},{".class":"LiteralType","fallback":"builtins.str","value":"=H"},{".class":"LiteralType","fallback":"builtins.str","value":"H"},{".class":"LiteralType","fallback":"builtins.str","value":"uintc"},{".class":"LiteralType","fallback":"builtins.str","value":"I"},{".class":"LiteralType","fallback":"builtins.str","value":"|I"},{".class":"LiteralType","fallback":"builtins.str","value":"=I"},{".class":"LiteralType","fallback":"builtins.str","value":"I"},{".class":"LiteralType","fallback":"builtins.str","value":"ulong"},{".class":"LiteralType","fallback":"builtins.str","value":"L"},{".class":"LiteralType","fallback":"builtins.str","value":"|L"},{".class":"LiteralType","fallback":"builtins.str","value":"=L"},{".class":"LiteralType","fallback":"builtins.str","value":"L"},{".class":"LiteralType","fallback":"builtins.str","value":"ulonglong"},{".class":"LiteralType","fallback":"builtins.str","value":"Q"},{".class":"LiteralType","fallback":"builtins.str","value":"|Q"},{".class":"LiteralType","fallback":"builtins.str","value":"=Q"},{".class":"LiteralType","fallback":"builtins.str","value":"Q"},{".class":"LiteralType","fallback":"builtins.str","value":"int8"},{".class":"LiteralType","fallback":"builtins.str","value":"i1"},{".class":"LiteralType","fallback":"builtins.str","value":"|i1"},{".class":"LiteralType","fallback":"builtins.str","value":"=i1"},{".class":"LiteralType","fallback":"builtins.str","value":"i1"},{".class":"LiteralType","fallback":"builtins.str","value":"int16"},{".class":"LiteralType","fallback":"builtins.str","value":"i2"},{".class":"LiteralType","fallback":"builtins.str","value":"|i2"},{".class":"LiteralType","fallback":"builtins.str","value":"=i2"},{".class":"LiteralType","fallback":"builtins.str","value":"i2"},{".class":"LiteralType","fallback":"builtins.str","value":"int32"},{".class":"LiteralType","fallback":"builtins.str","value":"i4"},{".class":"LiteralType","fallback":"builtins.str","value":"|i4"},{".class":"LiteralType","fallback":"builtins.str","value":"=i4"},{".class":"LiteralType","fallback":"builtins.str","value":"i4"},{".class":"LiteralType","fallback":"builtins.str","value":"int64"},{".class":"LiteralType","fallback":"builtins.str","value":"i8"},{".class":"LiteralType","fallback":"builtins.str","value":"|i8"},{".class":"LiteralType","fallback":"builtins.str","value":"=i8"},{".class":"LiteralType","fallback":"builtins.str","value":"i8"},{".class":"LiteralType","fallback":"builtins.str","value":"intp"},{".class":"LiteralType","fallback":"builtins.str","value":"int"},{".class":"LiteralType","fallback":"builtins.str","value":"int_"},{".class":"LiteralType","fallback":"builtins.str","value":"n"},{".class":"LiteralType","fallback":"builtins.str","value":"|n"},{".class":"LiteralType","fallback":"builtins.str","value":"=n"},{".class":"LiteralType","fallback":"builtins.str","value":"n"},{".class":"LiteralType","fallback":"builtins.str","value":"byte"},{".class":"LiteralType","fallback":"builtins.str","value":"b"},{".class":"LiteralType","fallback":"builtins.str","value":"|b"},{".class":"LiteralType","fallback":"builtins.str","value":"=b"},{".class":"LiteralType","fallback":"builtins.str","value":"b"},{".class":"LiteralType","fallback":"builtins.str","value":"short"},{".class":"LiteralType","fallback":"builtins.str","value":"h"},{".class":"LiteralType","fallback":"builtins.str","value":"|h"},{".class":"LiteralType","fallback":"builtins.str","value":"=h"},{".class":"LiteralType","fallback":"builtins.str","value":"h"},{".class":"LiteralType","fallback":"builtins.str","value":"intc"},{".class":"LiteralType","fallback":"builtins.str","value":"i"},{".class":"LiteralType","fallback":"builtins.str","value":"|i"},{".class":"LiteralType","fallback":"builtins.str","value":"=i"},{".class":"LiteralType","fallback":"builtins.str","value":"i"},{".class":"LiteralType","fallback":"builtins.str","value":"long"},{".class":"LiteralType","fallback":"builtins.str","value":"l"},{".class":"LiteralType","fallback":"builtins.str","value":"|l"},{".class":"LiteralType","fallback":"builtins.str","value":"=l"},{".class":"LiteralType","fallback":"builtins.str","value":"l"},{".class":"LiteralType","fallback":"builtins.str","value":"longlong"},{".class":"LiteralType","fallback":"builtins.str","value":"q"},{".class":"LiteralType","fallback":"builtins.str","value":"|q"},{".class":"LiteralType","fallback":"builtins.str","value":"=q"},{".class":"LiteralType","fallback":"builtins.str","value":"q"},{".class":"LiteralType","fallback":"builtins.str","value":"float16"},{".class":"LiteralType","fallback":"builtins.str","value":"f2"},{".class":"LiteralType","fallback":"builtins.str","value":"|f2"},{".class":"LiteralType","fallback":"builtins.str","value":"=f2"},{".class":"LiteralType","fallback":"builtins.str","value":"f2"},{".class":"LiteralType","fallback":"builtins.str","value":"float32"},{".class":"LiteralType","fallback":"builtins.str","value":"f4"},{".class":"LiteralType","fallback":"builtins.str","value":"|f4"},{".class":"LiteralType","fallback":"builtins.str","value":"=f4"},{".class":"LiteralType","fallback":"builtins.str","value":"f4"},{".class":"LiteralType","fallback":"builtins.str","value":"float64"},{".class":"LiteralType","fallback":"builtins.str","value":"f8"},{".class":"LiteralType","fallback":"builtins.str","value":"|f8"},{".class":"LiteralType","fallback":"builtins.str","value":"=f8"},{".class":"LiteralType","fallback":"builtins.str","value":"f8"},{".class":"LiteralType","fallback":"builtins.str","value":"half"},{".class":"LiteralType","fallback":"builtins.str","value":"e"},{".class":"LiteralType","fallback":"builtins.str","value":"|e"},{".class":"LiteralType","fallback":"builtins.str","value":"=e"},{".class":"LiteralType","fallback":"builtins.str","value":"e"},{".class":"LiteralType","fallback":"builtins.str","value":"single"},{".class":"LiteralType","fallback":"builtins.str","value":"f"},{".class":"LiteralType","fallback":"builtins.str","value":"|f"},{".class":"LiteralType","fallback":"builtins.str","value":"=f"},{".class":"LiteralType","fallback":"builtins.str","value":"f"},{".class":"LiteralType","fallback":"builtins.str","value":"double"},{".class":"LiteralType","fallback":"builtins.str","value":"float"},{".class":"LiteralType","fallback":"builtins.str","value":"d"},{".class":"LiteralType","fallback":"builtins.str","value":"|d"},{".class":"LiteralType","fallback":"builtins.str","value":"=d"},{".class":"LiteralType","fallback":"builtins.str","value":"d"},{".class":"LiteralType","fallback":"builtins.str","value":"longdouble"},{".class":"LiteralType","fallback":"builtins.str","value":"g"},{".class":"LiteralType","fallback":"builtins.str","value":"|g"},{".class":"LiteralType","fallback":"builtins.str","value":"=g"},{".class":"LiteralType","fallback":"builtins.str","value":"g"},{".class":"LiteralType","fallback":"builtins.str","value":"complex64"},{".class":"LiteralType","fallback":"builtins.str","value":"c8"},{".class":"LiteralType","fallback":"builtins.str","value":"|c8"},{".class":"LiteralType","fallback":"builtins.str","value":"=c8"},{".class":"LiteralType","fallback":"builtins.str","value":"c8"},{".class":"LiteralType","fallback":"builtins.str","value":"complex128"},{".class":"LiteralType","fallback":"builtins.str","value":"c16"},{".class":"LiteralType","fallback":"builtins.str","value":"|c16"},{".class":"LiteralType","fallback":"builtins.str","value":"=c16"},{".class":"LiteralType","fallback":"builtins.str","value":"c16"},{".class":"LiteralType","fallback":"builtins.str","value":"csingle"},{".class":"LiteralType","fallback":"builtins.str","value":"F"},{".class":"LiteralType","fallback":"builtins.str","value":"|F"},{".class":"LiteralType","fallback":"builtins.str","value":"=F"},{".class":"LiteralType","fallback":"builtins.str","value":"F"},{".class":"LiteralType","fallback":"builtins.str","value":"cdouble"},{".class":"LiteralType","fallback":"builtins.str","value":"complex"},{".class":"LiteralType","fallback":"builtins.str","value":"D"},{".class":"LiteralType","fallback":"builtins.str","value":"|D"},{".class":"LiteralType","fallback":"builtins.str","value":"=D"},{".class":"LiteralType","fallback":"builtins.str","value":"D"},{".class":"LiteralType","fallback":"builtins.str","value":"clongdouble"},{".class":"LiteralType","fallback":"builtins.str","value":"G"},{".class":"LiteralType","fallback":"builtins.str","value":"|G"},{".class":"LiteralType","fallback":"builtins.str","value":"=G"},{".class":"LiteralType","fallback":"builtins.str","value":"G"},{".class":"LiteralType","fallback":"builtins.str","value":"void"},{".class":"LiteralType","fallback":"builtins.str","value":"V"},{".class":"LiteralType","fallback":"builtins.str","value":"|V"},{".class":"LiteralType","fallback":"builtins.str","value":"=V"},{".class":"LiteralType","fallback":"builtins.str","value":"V"},{".class":"LiteralType","fallback":"builtins.str","value":"str"},{".class":"LiteralType","fallback":"builtins.str","value":"str_"},{".class":"LiteralType","fallback":"builtins.str","value":"unicode"},{".class":"LiteralType","fallback":"builtins.str","value":"U"},{".class":"LiteralType","fallback":"builtins.str","value":"|U"},{".class":"LiteralType","fallback":"builtins.str","value":"=U"},{".class":"LiteralType","fallback":"builtins.str","value":"U"},{".class":"LiteralType","fallback":"builtins.str","value":"bytes"},{".class":"LiteralType","fallback":"builtins.str","value":"bytes_"},{".class":"LiteralType","fallback":"builtins.str","value":"S"},{".class":"LiteralType","fallback":"builtins.str","value":"|S"},{".class":"LiteralType","fallback":"builtins.str","value":"=S"},{".class":"LiteralType","fallback":"builtins.str","value":"S"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64"},{".class":"LiteralType","fallback":"builtins.str","value":"|datetime64"},{".class":"LiteralType","fallback":"builtins.str","value":"=datetime64"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[Y]"},{".class":"LiteralType","fallback":"builtins.str","value":"|datetime64[Y]"},{".class":"LiteralType","fallback":"builtins.str","value":"=datetime64[Y]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[Y]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[M]"},{".class":"LiteralType","fallback":"builtins.str","value":"|datetime64[M]"},{".class":"LiteralType","fallback":"builtins.str","value":"=datetime64[M]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[M]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[W]"},{".class":"LiteralType","fallback":"builtins.str","value":"|datetime64[W]"},{".class":"LiteralType","fallback":"builtins.str","value":"=datetime64[W]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[W]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[D]"},{".class":"LiteralType","fallback":"builtins.str","value":"|datetime64[D]"},{".class":"LiteralType","fallback":"builtins.str","value":"=datetime64[D]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[D]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[h]"},{".class":"LiteralType","fallback":"builtins.str","value":"|datetime64[h]"},{".class":"LiteralType","fallback":"builtins.str","value":"=datetime64[h]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[h]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[m]"},{".class":"LiteralType","fallback":"builtins.str","value":"|datetime64[m]"},{".class":"LiteralType","fallback":"builtins.str","value":"=datetime64[m]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[m]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[s]"},{".class":"LiteralType","fallback":"builtins.str","value":"|datetime64[s]"},{".class":"LiteralType","fallback":"builtins.str","value":"=datetime64[s]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[s]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[ms]"},{".class":"LiteralType","fallback":"builtins.str","value":"|datetime64[ms]"},{".class":"LiteralType","fallback":"builtins.str","value":"=datetime64[ms]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[ms]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[us]"},{".class":"LiteralType","fallback":"builtins.str","value":"|datetime64[us]"},{".class":"LiteralType","fallback":"builtins.str","value":"=datetime64[us]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[us]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[ns]"},{".class":"LiteralType","fallback":"builtins.str","value":"|datetime64[ns]"},{".class":"LiteralType","fallback":"builtins.str","value":"=datetime64[ns]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[ns]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[ps]"},{".class":"LiteralType","fallback":"builtins.str","value":"|datetime64[ps]"},{".class":"LiteralType","fallback":"builtins.str","value":"=datetime64[ps]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[ps]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[fs]"},{".class":"LiteralType","fallback":"builtins.str","value":"|datetime64[fs]"},{".class":"LiteralType","fallback":"builtins.str","value":"=datetime64[fs]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[fs]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[as]"},{".class":"LiteralType","fallback":"builtins.str","value":"|datetime64[as]"},{".class":"LiteralType","fallback":"builtins.str","value":"=datetime64[as]"},{".class":"LiteralType","fallback":"builtins.str","value":"datetime64[as]"},{".class":"LiteralType","fallback":"builtins.str","value":"M"},{".class":"LiteralType","fallback":"builtins.str","value":"|M"},{".class":"LiteralType","fallback":"builtins.str","value":"=M"},{".class":"LiteralType","fallback":"builtins.str","value":"M"},{".class":"LiteralType","fallback":"builtins.str","value":"M8"},{".class":"LiteralType","fallback":"builtins.str","value":"|M8"},{".class":"LiteralType","fallback":"builtins.str","value":"=M8"},{".class":"LiteralType","fallback":"builtins.str","value":"M8"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[Y]"},{".class":"LiteralType","fallback":"builtins.str","value":"|M8[Y]"},{".class":"LiteralType","fallback":"builtins.str","value":"=M8[Y]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[Y]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[M]"},{".class":"LiteralType","fallback":"builtins.str","value":"|M8[M]"},{".class":"LiteralType","fallback":"builtins.str","value":"=M8[M]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[M]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[W]"},{".class":"LiteralType","fallback":"builtins.str","value":"|M8[W]"},{".class":"LiteralType","fallback":"builtins.str","value":"=M8[W]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[W]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[D]"},{".class":"LiteralType","fallback":"builtins.str","value":"|M8[D]"},{".class":"LiteralType","fallback":"builtins.str","value":"=M8[D]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[D]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[h]"},{".class":"LiteralType","fallback":"builtins.str","value":"|M8[h]"},{".class":"LiteralType","fallback":"builtins.str","value":"=M8[h]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[h]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[m]"},{".class":"LiteralType","fallback":"builtins.str","value":"|M8[m]"},{".class":"LiteralType","fallback":"builtins.str","value":"=M8[m]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[m]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[s]"},{".class":"LiteralType","fallback":"builtins.str","value":"|M8[s]"},{".class":"LiteralType","fallback":"builtins.str","value":"=M8[s]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[s]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[ms]"},{".class":"LiteralType","fallback":"builtins.str","value":"|M8[ms]"},{".class":"LiteralType","fallback":"builtins.str","value":"=M8[ms]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[ms]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[us]"},{".class":"LiteralType","fallback":"builtins.str","value":"|M8[us]"},{".class":"LiteralType","fallback":"builtins.str","value":"=M8[us]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[us]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[ns]"},{".class":"LiteralType","fallback":"builtins.str","value":"|M8[ns]"},{".class":"LiteralType","fallback":"builtins.str","value":"=M8[ns]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[ns]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[ps]"},{".class":"LiteralType","fallback":"builtins.str","value":"|M8[ps]"},{".class":"LiteralType","fallback":"builtins.str","value":"=M8[ps]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[ps]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[fs]"},{".class":"LiteralType","fallback":"builtins.str","value":"|M8[fs]"},{".class":"LiteralType","fallback":"builtins.str","value":"=M8[fs]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[fs]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[as]"},{".class":"LiteralType","fallback":"builtins.str","value":"|M8[as]"},{".class":"LiteralType","fallback":"builtins.str","value":"=M8[as]"},{".class":"LiteralType","fallback":"builtins.str","value":"M8[as]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64"},{".class":"LiteralType","fallback":"builtins.str","value":"|timedelta64"},{".class":"LiteralType","fallback":"builtins.str","value":"=timedelta64"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[Y]"},{".class":"LiteralType","fallback":"builtins.str","value":"|timedelta64[Y]"},{".class":"LiteralType","fallback":"builtins.str","value":"=timedelta64[Y]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[Y]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[M]"},{".class":"LiteralType","fallback":"builtins.str","value":"|timedelta64[M]"},{".class":"LiteralType","fallback":"builtins.str","value":"=timedelta64[M]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[M]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[W]"},{".class":"LiteralType","fallback":"builtins.str","value":"|timedelta64[W]"},{".class":"LiteralType","fallback":"builtins.str","value":"=timedelta64[W]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[W]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[D]"},{".class":"LiteralType","fallback":"builtins.str","value":"|timedelta64[D]"},{".class":"LiteralType","fallback":"builtins.str","value":"=timedelta64[D]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[D]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[h]"},{".class":"LiteralType","fallback":"builtins.str","value":"|timedelta64[h]"},{".class":"LiteralType","fallback":"builtins.str","value":"=timedelta64[h]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[h]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[m]"},{".class":"LiteralType","fallback":"builtins.str","value":"|timedelta64[m]"},{".class":"LiteralType","fallback":"builtins.str","value":"=timedelta64[m]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[m]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[s]"},{".class":"LiteralType","fallback":"builtins.str","value":"|timedelta64[s]"},{".class":"LiteralType","fallback":"builtins.str","value":"=timedelta64[s]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[s]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[ms]"},{".class":"LiteralType","fallback":"builtins.str","value":"|timedelta64[ms]"},{".class":"LiteralType","fallback":"builtins.str","value":"=timedelta64[ms]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[ms]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[us]"},{".class":"LiteralType","fallback":"builtins.str","value":"|timedelta64[us]"},{".class":"LiteralType","fallback":"builtins.str","value":"=timedelta64[us]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[us]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[ns]"},{".class":"LiteralType","fallback":"builtins.str","value":"|timedelta64[ns]"},{".class":"LiteralType","fallback":"builtins.str","value":"=timedelta64[ns]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[ns]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[ps]"},{".class":"LiteralType","fallback":"builtins.str","value":"|timedelta64[ps]"},{".class":"LiteralType","fallback":"builtins.str","value":"=timedelta64[ps]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[ps]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[fs]"},{".class":"LiteralType","fallback":"builtins.str","value":"|timedelta64[fs]"},{".class":"LiteralType","fallback":"builtins.str","value":"=timedelta64[fs]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[fs]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[as]"},{".class":"LiteralType","fallback":"builtins.str","value":"|timedelta64[as]"},{".class":"LiteralType","fallback":"builtins.str","value":"=timedelta64[as]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[as]"},{".class":"LiteralType","fallback":"builtins.str","value":"m"},{".class":"LiteralType","fallback":"builtins.str","value":"|m"},{".class":"LiteralType","fallback":"builtins.str","value":"=m"},{".class":"LiteralType","fallback":"builtins.str","value":"m"},{".class":"LiteralType","fallback":"builtins.str","value":"m8"},{".class":"LiteralType","fallback":"builtins.str","value":"|m8"},{".class":"LiteralType","fallback":"builtins.str","value":"=m8"},{".class":"LiteralType","fallback":"builtins.str","value":"m8"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[Y]"},{".class":"LiteralType","fallback":"builtins.str","value":"|m8[Y]"},{".class":"LiteralType","fallback":"builtins.str","value":"=m8[Y]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[Y]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[M]"},{".class":"LiteralType","fallback":"builtins.str","value":"|m8[M]"},{".class":"LiteralType","fallback":"builtins.str","value":"=m8[M]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[M]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[W]"},{".class":"LiteralType","fallback":"builtins.str","value":"|m8[W]"},{".class":"LiteralType","fallback":"builtins.str","value":"=m8[W]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[W]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[D]"},{".class":"LiteralType","fallback":"builtins.str","value":"|m8[D]"},{".class":"LiteralType","fallback":"builtins.str","value":"=m8[D]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[D]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[h]"},{".class":"LiteralType","fallback":"builtins.str","value":"|m8[h]"},{".class":"LiteralType","fallback":"builtins.str","value":"=m8[h]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[h]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[m]"},{".class":"LiteralType","fallback":"builtins.str","value":"|m8[m]"},{".class":"LiteralType","fallback":"builtins.str","value":"=m8[m]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[m]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[s]"},{".class":"LiteralType","fallback":"builtins.str","value":"|m8[s]"},{".class":"LiteralType","fallback":"builtins.str","value":"=m8[s]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[s]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[ms]"},{".class":"LiteralType","fallback":"builtins.str","value":"|m8[ms]"},{".class":"LiteralType","fallback":"builtins.str","value":"=m8[ms]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[ms]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[us]"},{".class":"LiteralType","fallback":"builtins.str","value":"|m8[us]"},{".class":"LiteralType","fallback":"builtins.str","value":"=m8[us]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[us]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[ns]"},{".class":"LiteralType","fallback":"builtins.str","value":"|m8[ns]"},{".class":"LiteralType","fallback":"builtins.str","value":"=m8[ns]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[ns]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[ps]"},{".class":"LiteralType","fallback":"builtins.str","value":"|m8[ps]"},{".class":"LiteralType","fallback":"builtins.str","value":"=m8[ps]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[ps]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[fs]"},{".class":"LiteralType","fallback":"builtins.str","value":"|m8[fs]"},{".class":"LiteralType","fallback":"builtins.str","value":"=m8[fs]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[fs]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[as]"},{".class":"LiteralType","fallback":"builtins.str","value":"|m8[as]"},{".class":"LiteralType","fallback":"builtins.str","value":"=m8[as]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[as]"},{".class":"LiteralType","fallback":"builtins.str","value":"object"},{".class":"LiteralType","fallback":"builtins.str","value":"object_"},{".class":"LiteralType","fallback":"builtins.str","value":"O"},{".class":"LiteralType","fallback":"builtins.str","value":"|O"},{".class":"LiteralType","fallback":"builtins.str","value":"=O"},{".class":"LiteralType","fallback":"builtins.str","value":"O"}],"uses_pep604_syntax":false}}},"_HalfCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._HalfCodes","line":42,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"half"},{".class":"LiteralType","fallback":"builtins.str","value":"e"},{".class":"LiteralType","fallback":"builtins.str","value":"|e"},{".class":"LiteralType","fallback":"builtins.str","value":"=e"},{".class":"LiteralType","fallback":"builtins.str","value":"e"}],"uses_pep604_syntax":false}}},"_InexactCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._InexactCodes","line":198,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"float16"},{".class":"LiteralType","fallback":"builtins.str","value":"f2"},{".class":"LiteralType","fallback":"builtins.str","value":"|f2"},{".class":"LiteralType","fallback":"builtins.str","value":"=f2"},{".class":"LiteralType","fallback":"builtins.str","value":"f2"},{".class":"LiteralType","fallback":"builtins.str","value":"float32"},{".class":"LiteralType","fallback":"builtins.str","value":"f4"},{".class":"LiteralType","fallback":"builtins.str","value":"|f4"},{".class":"LiteralType","fallback":"builtins.str","value":"=f4"},{".class":"LiteralType","fallback":"builtins.str","value":"f4"},{".class":"LiteralType","fallback":"builtins.str","value":"float64"},{".class":"LiteralType","fallback":"builtins.str","value":"f8"},{".class":"LiteralType","fallback":"builtins.str","value":"|f8"},{".class":"LiteralType","fallback":"builtins.str","value":"=f8"},{".class":"LiteralType","fallback":"builtins.str","value":"f8"},{".class":"LiteralType","fallback":"builtins.str","value":"half"},{".class":"LiteralType","fallback":"builtins.str","value":"e"},{".class":"LiteralType","fallback":"builtins.str","value":"|e"},{".class":"LiteralType","fallback":"builtins.str","value":"=e"},{".class":"LiteralType","fallback":"builtins.str","value":"e"},{".class":"LiteralType","fallback":"builtins.str","value":"single"},{".class":"LiteralType","fallback":"builtins.str","value":"f"},{".class":"LiteralType","fallback":"builtins.str","value":"|f"},{".class":"LiteralType","fallback":"builtins.str","value":"=f"},{".class":"LiteralType","fallback":"builtins.str","value":"f"},{".class":"LiteralType","fallback":"builtins.str","value":"double"},{".class":"LiteralType","fallback":"builtins.str","value":"float"},{".class":"LiteralType","fallback":"builtins.str","value":"d"},{".class":"LiteralType","fallback":"builtins.str","value":"|d"},{".class":"LiteralType","fallback":"builtins.str","value":"=d"},{".class":"LiteralType","fallback":"builtins.str","value":"d"},{".class":"LiteralType","fallback":"builtins.str","value":"longdouble"},{".class":"LiteralType","fallback":"builtins.str","value":"g"},{".class":"LiteralType","fallback":"builtins.str","value":"|g"},{".class":"LiteralType","fallback":"builtins.str","value":"=g"},{".class":"LiteralType","fallback":"builtins.str","value":"g"},{".class":"LiteralType","fallback":"builtins.str","value":"complex64"},{".class":"LiteralType","fallback":"builtins.str","value":"c8"},{".class":"LiteralType","fallback":"builtins.str","value":"|c8"},{".class":"LiteralType","fallback":"builtins.str","value":"=c8"},{".class":"LiteralType","fallback":"builtins.str","value":"c8"},{".class":"LiteralType","fallback":"builtins.str","value":"complex128"},{".class":"LiteralType","fallback":"builtins.str","value":"c16"},{".class":"LiteralType","fallback":"builtins.str","value":"|c16"},{".class":"LiteralType","fallback":"builtins.str","value":"=c16"},{".class":"LiteralType","fallback":"builtins.str","value":"c16"},{".class":"LiteralType","fallback":"builtins.str","value":"csingle"},{".class":"LiteralType","fallback":"builtins.str","value":"F"},{".class":"LiteralType","fallback":"builtins.str","value":"|F"},{".class":"LiteralType","fallback":"builtins.str","value":"=F"},{".class":"LiteralType","fallback":"builtins.str","value":"F"},{".class":"LiteralType","fallback":"builtins.str","value":"cdouble"},{".class":"LiteralType","fallback":"builtins.str","value":"complex"},{".class":"LiteralType","fallback":"builtins.str","value":"D"},{".class":"LiteralType","fallback":"builtins.str","value":"|D"},{".class":"LiteralType","fallback":"builtins.str","value":"=D"},{".class":"LiteralType","fallback":"builtins.str","value":"D"},{".class":"LiteralType","fallback":"builtins.str","value":"clongdouble"},{".class":"LiteralType","fallback":"builtins.str","value":"G"},{".class":"LiteralType","fallback":"builtins.str","value":"|G"},{".class":"LiteralType","fallback":"builtins.str","value":"=G"},{".class":"LiteralType","fallback":"builtins.str","value":"G"}],"uses_pep604_syntax":false}}},"_Int16Codes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._Int16Codes","line":15,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"int16"},{".class":"LiteralType","fallback":"builtins.str","value":"i2"},{".class":"LiteralType","fallback":"builtins.str","value":"|i2"},{".class":"LiteralType","fallback":"builtins.str","value":"=i2"},{".class":"LiteralType","fallback":"builtins.str","value":"i2"}],"uses_pep604_syntax":false}}},"_Int32Codes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._Int32Codes","line":16,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"int32"},{".class":"LiteralType","fallback":"builtins.str","value":"i4"},{".class":"LiteralType","fallback":"builtins.str","value":"|i4"},{".class":"LiteralType","fallback":"builtins.str","value":"=i4"},{".class":"LiteralType","fallback":"builtins.str","value":"i4"}],"uses_pep604_syntax":false}}},"_Int64Codes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._Int64Codes","line":17,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"int64"},{".class":"LiteralType","fallback":"builtins.str","value":"i8"},{".class":"LiteralType","fallback":"builtins.str","value":"|i8"},{".class":"LiteralType","fallback":"builtins.str","value":"=i8"},{".class":"LiteralType","fallback":"builtins.str","value":"i8"}],"uses_pep604_syntax":false}}},"_Int8Codes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._Int8Codes","line":14,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"int8"},{".class":"LiteralType","fallback":"builtins.str","value":"i1"},{".class":"LiteralType","fallback":"builtins.str","value":"|i1"},{".class":"LiteralType","fallback":"builtins.str","value":"=i1"},{".class":"LiteralType","fallback":"builtins.str","value":"i1"}],"uses_pep604_syntax":false}}},"_IntCCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._IntCCodes","line":28,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"intc"},{".class":"LiteralType","fallback":"builtins.str","value":"i"},{".class":"LiteralType","fallback":"builtins.str","value":"|i"},{".class":"LiteralType","fallback":"builtins.str","value":"=i"},{".class":"LiteralType","fallback":"builtins.str","value":"i"}],"uses_pep604_syntax":false}}},"_IntCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._IntCodes","line":31,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._IntPCodes"}}},"_IntPCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._IntPCodes","line":29,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"intp"},{".class":"LiteralType","fallback":"builtins.str","value":"int"},{".class":"LiteralType","fallback":"builtins.str","value":"int_"},{".class":"LiteralType","fallback":"builtins.str","value":"n"},{".class":"LiteralType","fallback":"builtins.str","value":"|n"},{".class":"LiteralType","fallback":"builtins.str","value":"=n"},{".class":"LiteralType","fallback":"builtins.str","value":"n"}],"uses_pep604_syntax":false}}},"_IntegerCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._IntegerCodes","line":197,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"uint8"},{".class":"LiteralType","fallback":"builtins.str","value":"u1"},{".class":"LiteralType","fallback":"builtins.str","value":"|u1"},{".class":"LiteralType","fallback":"builtins.str","value":"=u1"},{".class":"LiteralType","fallback":"builtins.str","value":"u1"},{".class":"LiteralType","fallback":"builtins.str","value":"uint16"},{".class":"LiteralType","fallback":"builtins.str","value":"u2"},{".class":"LiteralType","fallback":"builtins.str","value":"|u2"},{".class":"LiteralType","fallback":"builtins.str","value":"=u2"},{".class":"LiteralType","fallback":"builtins.str","value":"u2"},{".class":"LiteralType","fallback":"builtins.str","value":"uint32"},{".class":"LiteralType","fallback":"builtins.str","value":"u4"},{".class":"LiteralType","fallback":"builtins.str","value":"|u4"},{".class":"LiteralType","fallback":"builtins.str","value":"=u4"},{".class":"LiteralType","fallback":"builtins.str","value":"u4"},{".class":"LiteralType","fallback":"builtins.str","value":"uint64"},{".class":"LiteralType","fallback":"builtins.str","value":"u8"},{".class":"LiteralType","fallback":"builtins.str","value":"|u8"},{".class":"LiteralType","fallback":"builtins.str","value":"=u8"},{".class":"LiteralType","fallback":"builtins.str","value":"u8"},{".class":"LiteralType","fallback":"builtins.str","value":"uintp"},{".class":"LiteralType","fallback":"builtins.str","value":"uint"},{".class":"LiteralType","fallback":"builtins.str","value":"N"},{".class":"LiteralType","fallback":"builtins.str","value":"|N"},{".class":"LiteralType","fallback":"builtins.str","value":"=N"},{".class":"LiteralType","fallback":"builtins.str","value":"N"},{".class":"LiteralType","fallback":"builtins.str","value":"ubyte"},{".class":"LiteralType","fallback":"builtins.str","value":"B"},{".class":"LiteralType","fallback":"builtins.str","value":"|B"},{".class":"LiteralType","fallback":"builtins.str","value":"=B"},{".class":"LiteralType","fallback":"builtins.str","value":"B"},{".class":"LiteralType","fallback":"builtins.str","value":"ushort"},{".class":"LiteralType","fallback":"builtins.str","value":"H"},{".class":"LiteralType","fallback":"builtins.str","value":"|H"},{".class":"LiteralType","fallback":"builtins.str","value":"=H"},{".class":"LiteralType","fallback":"builtins.str","value":"H"},{".class":"LiteralType","fallback":"builtins.str","value":"uintc"},{".class":"LiteralType","fallback":"builtins.str","value":"I"},{".class":"LiteralType","fallback":"builtins.str","value":"|I"},{".class":"LiteralType","fallback":"builtins.str","value":"=I"},{".class":"LiteralType","fallback":"builtins.str","value":"I"},{".class":"LiteralType","fallback":"builtins.str","value":"ulong"},{".class":"LiteralType","fallback":"builtins.str","value":"L"},{".class":"LiteralType","fallback":"builtins.str","value":"|L"},{".class":"LiteralType","fallback":"builtins.str","value":"=L"},{".class":"LiteralType","fallback":"builtins.str","value":"L"},{".class":"LiteralType","fallback":"builtins.str","value":"ulonglong"},{".class":"LiteralType","fallback":"builtins.str","value":"Q"},{".class":"LiteralType","fallback":"builtins.str","value":"|Q"},{".class":"LiteralType","fallback":"builtins.str","value":"=Q"},{".class":"LiteralType","fallback":"builtins.str","value":"Q"},{".class":"LiteralType","fallback":"builtins.str","value":"int8"},{".class":"LiteralType","fallback":"builtins.str","value":"i1"},{".class":"LiteralType","fallback":"builtins.str","value":"|i1"},{".class":"LiteralType","fallback":"builtins.str","value":"=i1"},{".class":"LiteralType","fallback":"builtins.str","value":"i1"},{".class":"LiteralType","fallback":"builtins.str","value":"int16"},{".class":"LiteralType","fallback":"builtins.str","value":"i2"},{".class":"LiteralType","fallback":"builtins.str","value":"|i2"},{".class":"LiteralType","fallback":"builtins.str","value":"=i2"},{".class":"LiteralType","fallback":"builtins.str","value":"i2"},{".class":"LiteralType","fallback":"builtins.str","value":"int32"},{".class":"LiteralType","fallback":"builtins.str","value":"i4"},{".class":"LiteralType","fallback":"builtins.str","value":"|i4"},{".class":"LiteralType","fallback":"builtins.str","value":"=i4"},{".class":"LiteralType","fallback":"builtins.str","value":"i4"},{".class":"LiteralType","fallback":"builtins.str","value":"int64"},{".class":"LiteralType","fallback":"builtins.str","value":"i8"},{".class":"LiteralType","fallback":"builtins.str","value":"|i8"},{".class":"LiteralType","fallback":"builtins.str","value":"=i8"},{".class":"LiteralType","fallback":"builtins.str","value":"i8"},{".class":"LiteralType","fallback":"builtins.str","value":"intp"},{".class":"LiteralType","fallback":"builtins.str","value":"int"},{".class":"LiteralType","fallback":"builtins.str","value":"int_"},{".class":"LiteralType","fallback":"builtins.str","value":"n"},{".class":"LiteralType","fallback":"builtins.str","value":"|n"},{".class":"LiteralType","fallback":"builtins.str","value":"=n"},{".class":"LiteralType","fallback":"builtins.str","value":"n"},{".class":"LiteralType","fallback":"builtins.str","value":"byte"},{".class":"LiteralType","fallback":"builtins.str","value":"b"},{".class":"LiteralType","fallback":"builtins.str","value":"|b"},{".class":"LiteralType","fallback":"builtins.str","value":"=b"},{".class":"LiteralType","fallback":"builtins.str","value":"b"},{".class":"LiteralType","fallback":"builtins.str","value":"short"},{".class":"LiteralType","fallback":"builtins.str","value":"h"},{".class":"LiteralType","fallback":"builtins.str","value":"|h"},{".class":"LiteralType","fallback":"builtins.str","value":"=h"},{".class":"LiteralType","fallback":"builtins.str","value":"h"},{".class":"LiteralType","fallback":"builtins.str","value":"intc"},{".class":"LiteralType","fallback":"builtins.str","value":"i"},{".class":"LiteralType","fallback":"builtins.str","value":"|i"},{".class":"LiteralType","fallback":"builtins.str","value":"=i"},{".class":"LiteralType","fallback":"builtins.str","value":"i"},{".class":"LiteralType","fallback":"builtins.str","value":"long"},{".class":"LiteralType","fallback":"builtins.str","value":"l"},{".class":"LiteralType","fallback":"builtins.str","value":"|l"},{".class":"LiteralType","fallback":"builtins.str","value":"=l"},{".class":"LiteralType","fallback":"builtins.str","value":"l"},{".class":"LiteralType","fallback":"builtins.str","value":"longlong"},{".class":"LiteralType","fallback":"builtins.str","value":"q"},{".class":"LiteralType","fallback":"builtins.str","value":"|q"},{".class":"LiteralType","fallback":"builtins.str","value":"=q"},{".class":"LiteralType","fallback":"builtins.str","value":"q"}],"uses_pep604_syntax":false}}},"_LongCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._LongCodes","line":30,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"long"},{".class":"LiteralType","fallback":"builtins.str","value":"l"},{".class":"LiteralType","fallback":"builtins.str","value":"|l"},{".class":"LiteralType","fallback":"builtins.str","value":"=l"},{".class":"LiteralType","fallback":"builtins.str","value":"l"}],"uses_pep604_syntax":false}}},"_LongDoubleCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._LongDoubleCodes","line":45,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"longdouble"},{".class":"LiteralType","fallback":"builtins.str","value":"g"},{".class":"LiteralType","fallback":"builtins.str","value":"|g"},{".class":"LiteralType","fallback":"builtins.str","value":"=g"},{".class":"LiteralType","fallback":"builtins.str","value":"g"}],"uses_pep604_syntax":false}}},"_LongLongCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._LongLongCodes","line":32,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"longlong"},{".class":"LiteralType","fallback":"builtins.str","value":"q"},{".class":"LiteralType","fallback":"builtins.str","value":"|q"},{".class":"LiteralType","fallback":"builtins.str","value":"=q"},{".class":"LiteralType","fallback":"builtins.str","value":"q"}],"uses_pep604_syntax":false}}},"_NumberCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._NumberCodes","line":199,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"uint8"},{".class":"LiteralType","fallback":"builtins.str","value":"u1"},{".class":"LiteralType","fallback":"builtins.str","value":"|u1"},{".class":"LiteralType","fallback":"builtins.str","value":"=u1"},{".class":"LiteralType","fallback":"builtins.str","value":"u1"},{".class":"LiteralType","fallback":"builtins.str","value":"uint16"},{".class":"LiteralType","fallback":"builtins.str","value":"u2"},{".class":"LiteralType","fallback":"builtins.str","value":"|u2"},{".class":"LiteralType","fallback":"builtins.str","value":"=u2"},{".class":"LiteralType","fallback":"builtins.str","value":"u2"},{".class":"LiteralType","fallback":"builtins.str","value":"uint32"},{".class":"LiteralType","fallback":"builtins.str","value":"u4"},{".class":"LiteralType","fallback":"builtins.str","value":"|u4"},{".class":"LiteralType","fallback":"builtins.str","value":"=u4"},{".class":"LiteralType","fallback":"builtins.str","value":"u4"},{".class":"LiteralType","fallback":"builtins.str","value":"uint64"},{".class":"LiteralType","fallback":"builtins.str","value":"u8"},{".class":"LiteralType","fallback":"builtins.str","value":"|u8"},{".class":"LiteralType","fallback":"builtins.str","value":"=u8"},{".class":"LiteralType","fallback":"builtins.str","value":"u8"},{".class":"LiteralType","fallback":"builtins.str","value":"uintp"},{".class":"LiteralType","fallback":"builtins.str","value":"uint"},{".class":"LiteralType","fallback":"builtins.str","value":"N"},{".class":"LiteralType","fallback":"builtins.str","value":"|N"},{".class":"LiteralType","fallback":"builtins.str","value":"=N"},{".class":"LiteralType","fallback":"builtins.str","value":"N"},{".class":"LiteralType","fallback":"builtins.str","value":"ubyte"},{".class":"LiteralType","fallback":"builtins.str","value":"B"},{".class":"LiteralType","fallback":"builtins.str","value":"|B"},{".class":"LiteralType","fallback":"builtins.str","value":"=B"},{".class":"LiteralType","fallback":"builtins.str","value":"B"},{".class":"LiteralType","fallback":"builtins.str","value":"ushort"},{".class":"LiteralType","fallback":"builtins.str","value":"H"},{".class":"LiteralType","fallback":"builtins.str","value":"|H"},{".class":"LiteralType","fallback":"builtins.str","value":"=H"},{".class":"LiteralType","fallback":"builtins.str","value":"H"},{".class":"LiteralType","fallback":"builtins.str","value":"uintc"},{".class":"LiteralType","fallback":"builtins.str","value":"I"},{".class":"LiteralType","fallback":"builtins.str","value":"|I"},{".class":"LiteralType","fallback":"builtins.str","value":"=I"},{".class":"LiteralType","fallback":"builtins.str","value":"I"},{".class":"LiteralType","fallback":"builtins.str","value":"ulong"},{".class":"LiteralType","fallback":"builtins.str","value":"L"},{".class":"LiteralType","fallback":"builtins.str","value":"|L"},{".class":"LiteralType","fallback":"builtins.str","value":"=L"},{".class":"LiteralType","fallback":"builtins.str","value":"L"},{".class":"LiteralType","fallback":"builtins.str","value":"ulonglong"},{".class":"LiteralType","fallback":"builtins.str","value":"Q"},{".class":"LiteralType","fallback":"builtins.str","value":"|Q"},{".class":"LiteralType","fallback":"builtins.str","value":"=Q"},{".class":"LiteralType","fallback":"builtins.str","value":"Q"},{".class":"LiteralType","fallback":"builtins.str","value":"int8"},{".class":"LiteralType","fallback":"builtins.str","value":"i1"},{".class":"LiteralType","fallback":"builtins.str","value":"|i1"},{".class":"LiteralType","fallback":"builtins.str","value":"=i1"},{".class":"LiteralType","fallback":"builtins.str","value":"i1"},{".class":"LiteralType","fallback":"builtins.str","value":"int16"},{".class":"LiteralType","fallback":"builtins.str","value":"i2"},{".class":"LiteralType","fallback":"builtins.str","value":"|i2"},{".class":"LiteralType","fallback":"builtins.str","value":"=i2"},{".class":"LiteralType","fallback":"builtins.str","value":"i2"},{".class":"LiteralType","fallback":"builtins.str","value":"int32"},{".class":"LiteralType","fallback":"builtins.str","value":"i4"},{".class":"LiteralType","fallback":"builtins.str","value":"|i4"},{".class":"LiteralType","fallback":"builtins.str","value":"=i4"},{".class":"LiteralType","fallback":"builtins.str","value":"i4"},{".class":"LiteralType","fallback":"builtins.str","value":"int64"},{".class":"LiteralType","fallback":"builtins.str","value":"i8"},{".class":"LiteralType","fallback":"builtins.str","value":"|i8"},{".class":"LiteralType","fallback":"builtins.str","value":"=i8"},{".class":"LiteralType","fallback":"builtins.str","value":"i8"},{".class":"LiteralType","fallback":"builtins.str","value":"intp"},{".class":"LiteralType","fallback":"builtins.str","value":"int"},{".class":"LiteralType","fallback":"builtins.str","value":"int_"},{".class":"LiteralType","fallback":"builtins.str","value":"n"},{".class":"LiteralType","fallback":"builtins.str","value":"|n"},{".class":"LiteralType","fallback":"builtins.str","value":"=n"},{".class":"LiteralType","fallback":"builtins.str","value":"n"},{".class":"LiteralType","fallback":"builtins.str","value":"byte"},{".class":"LiteralType","fallback":"builtins.str","value":"b"},{".class":"LiteralType","fallback":"builtins.str","value":"|b"},{".class":"LiteralType","fallback":"builtins.str","value":"=b"},{".class":"LiteralType","fallback":"builtins.str","value":"b"},{".class":"LiteralType","fallback":"builtins.str","value":"short"},{".class":"LiteralType","fallback":"builtins.str","value":"h"},{".class":"LiteralType","fallback":"builtins.str","value":"|h"},{".class":"LiteralType","fallback":"builtins.str","value":"=h"},{".class":"LiteralType","fallback":"builtins.str","value":"h"},{".class":"LiteralType","fallback":"builtins.str","value":"intc"},{".class":"LiteralType","fallback":"builtins.str","value":"i"},{".class":"LiteralType","fallback":"builtins.str","value":"|i"},{".class":"LiteralType","fallback":"builtins.str","value":"=i"},{".class":"LiteralType","fallback":"builtins.str","value":"i"},{".class":"LiteralType","fallback":"builtins.str","value":"long"},{".class":"LiteralType","fallback":"builtins.str","value":"l"},{".class":"LiteralType","fallback":"builtins.str","value":"|l"},{".class":"LiteralType","fallback":"builtins.str","value":"=l"},{".class":"LiteralType","fallback":"builtins.str","value":"l"},{".class":"LiteralType","fallback":"builtins.str","value":"longlong"},{".class":"LiteralType","fallback":"builtins.str","value":"q"},{".class":"LiteralType","fallback":"builtins.str","value":"|q"},{".class":"LiteralType","fallback":"builtins.str","value":"=q"},{".class":"LiteralType","fallback":"builtins.str","value":"q"},{".class":"LiteralType","fallback":"builtins.str","value":"float16"},{".class":"LiteralType","fallback":"builtins.str","value":"f2"},{".class":"LiteralType","fallback":"builtins.str","value":"|f2"},{".class":"LiteralType","fallback":"builtins.str","value":"=f2"},{".class":"LiteralType","fallback":"builtins.str","value":"f2"},{".class":"LiteralType","fallback":"builtins.str","value":"float32"},{".class":"LiteralType","fallback":"builtins.str","value":"f4"},{".class":"LiteralType","fallback":"builtins.str","value":"|f4"},{".class":"LiteralType","fallback":"builtins.str","value":"=f4"},{".class":"LiteralType","fallback":"builtins.str","value":"f4"},{".class":"LiteralType","fallback":"builtins.str","value":"float64"},{".class":"LiteralType","fallback":"builtins.str","value":"f8"},{".class":"LiteralType","fallback":"builtins.str","value":"|f8"},{".class":"LiteralType","fallback":"builtins.str","value":"=f8"},{".class":"LiteralType","fallback":"builtins.str","value":"f8"},{".class":"LiteralType","fallback":"builtins.str","value":"half"},{".class":"LiteralType","fallback":"builtins.str","value":"e"},{".class":"LiteralType","fallback":"builtins.str","value":"|e"},{".class":"LiteralType","fallback":"builtins.str","value":"=e"},{".class":"LiteralType","fallback":"builtins.str","value":"e"},{".class":"LiteralType","fallback":"builtins.str","value":"single"},{".class":"LiteralType","fallback":"builtins.str","value":"f"},{".class":"LiteralType","fallback":"builtins.str","value":"|f"},{".class":"LiteralType","fallback":"builtins.str","value":"=f"},{".class":"LiteralType","fallback":"builtins.str","value":"f"},{".class":"LiteralType","fallback":"builtins.str","value":"double"},{".class":"LiteralType","fallback":"builtins.str","value":"float"},{".class":"LiteralType","fallback":"builtins.str","value":"d"},{".class":"LiteralType","fallback":"builtins.str","value":"|d"},{".class":"LiteralType","fallback":"builtins.str","value":"=d"},{".class":"LiteralType","fallback":"builtins.str","value":"d"},{".class":"LiteralType","fallback":"builtins.str","value":"longdouble"},{".class":"LiteralType","fallback":"builtins.str","value":"g"},{".class":"LiteralType","fallback":"builtins.str","value":"|g"},{".class":"LiteralType","fallback":"builtins.str","value":"=g"},{".class":"LiteralType","fallback":"builtins.str","value":"g"},{".class":"LiteralType","fallback":"builtins.str","value":"complex64"},{".class":"LiteralType","fallback":"builtins.str","value":"c8"},{".class":"LiteralType","fallback":"builtins.str","value":"|c8"},{".class":"LiteralType","fallback":"builtins.str","value":"=c8"},{".class":"LiteralType","fallback":"builtins.str","value":"c8"},{".class":"LiteralType","fallback":"builtins.str","value":"complex128"},{".class":"LiteralType","fallback":"builtins.str","value":"c16"},{".class":"LiteralType","fallback":"builtins.str","value":"|c16"},{".class":"LiteralType","fallback":"builtins.str","value":"=c16"},{".class":"LiteralType","fallback":"builtins.str","value":"c16"},{".class":"LiteralType","fallback":"builtins.str","value":"csingle"},{".class":"LiteralType","fallback":"builtins.str","value":"F"},{".class":"LiteralType","fallback":"builtins.str","value":"|F"},{".class":"LiteralType","fallback":"builtins.str","value":"=F"},{".class":"LiteralType","fallback":"builtins.str","value":"F"},{".class":"LiteralType","fallback":"builtins.str","value":"cdouble"},{".class":"LiteralType","fallback":"builtins.str","value":"complex"},{".class":"LiteralType","fallback":"builtins.str","value":"D"},{".class":"LiteralType","fallback":"builtins.str","value":"|D"},{".class":"LiteralType","fallback":"builtins.str","value":"=D"},{".class":"LiteralType","fallback":"builtins.str","value":"D"},{".class":"LiteralType","fallback":"builtins.str","value":"clongdouble"},{".class":"LiteralType","fallback":"builtins.str","value":"G"},{".class":"LiteralType","fallback":"builtins.str","value":"|G"},{".class":"LiteralType","fallback":"builtins.str","value":"=G"},{".class":"LiteralType","fallback":"builtins.str","value":"G"}],"uses_pep604_syntax":false}}},"_ObjectCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._ObjectCodes","line":54,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"object"},{".class":"LiteralType","fallback":"builtins.str","value":"object_"},{".class":"LiteralType","fallback":"builtins.str","value":"O"},{".class":"LiteralType","fallback":"builtins.str","value":"|O"},{".class":"LiteralType","fallback":"builtins.str","value":"=O"},{".class":"LiteralType","fallback":"builtins.str","value":"O"}],"uses_pep604_syntax":false}}},"_ShortCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._ShortCodes","line":27,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"short"},{".class":"LiteralType","fallback":"builtins.str","value":"h"},{".class":"LiteralType","fallback":"builtins.str","value":"|h"},{".class":"LiteralType","fallback":"builtins.str","value":"=h"},{".class":"LiteralType","fallback":"builtins.str","value":"h"}],"uses_pep604_syntax":false}}},"_SignedIntegerCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._SignedIntegerCodes","line":169,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"int8"},{".class":"LiteralType","fallback":"builtins.str","value":"i1"},{".class":"LiteralType","fallback":"builtins.str","value":"|i1"},{".class":"LiteralType","fallback":"builtins.str","value":"=i1"},{".class":"LiteralType","fallback":"builtins.str","value":"i1"},{".class":"LiteralType","fallback":"builtins.str","value":"int16"},{".class":"LiteralType","fallback":"builtins.str","value":"i2"},{".class":"LiteralType","fallback":"builtins.str","value":"|i2"},{".class":"LiteralType","fallback":"builtins.str","value":"=i2"},{".class":"LiteralType","fallback":"builtins.str","value":"i2"},{".class":"LiteralType","fallback":"builtins.str","value":"int32"},{".class":"LiteralType","fallback":"builtins.str","value":"i4"},{".class":"LiteralType","fallback":"builtins.str","value":"|i4"},{".class":"LiteralType","fallback":"builtins.str","value":"=i4"},{".class":"LiteralType","fallback":"builtins.str","value":"i4"},{".class":"LiteralType","fallback":"builtins.str","value":"int64"},{".class":"LiteralType","fallback":"builtins.str","value":"i8"},{".class":"LiteralType","fallback":"builtins.str","value":"|i8"},{".class":"LiteralType","fallback":"builtins.str","value":"=i8"},{".class":"LiteralType","fallback":"builtins.str","value":"i8"},{".class":"LiteralType","fallback":"builtins.str","value":"intp"},{".class":"LiteralType","fallback":"builtins.str","value":"int"},{".class":"LiteralType","fallback":"builtins.str","value":"int_"},{".class":"LiteralType","fallback":"builtins.str","value":"n"},{".class":"LiteralType","fallback":"builtins.str","value":"|n"},{".class":"LiteralType","fallback":"builtins.str","value":"=n"},{".class":"LiteralType","fallback":"builtins.str","value":"n"},{".class":"LiteralType","fallback":"builtins.str","value":"byte"},{".class":"LiteralType","fallback":"builtins.str","value":"b"},{".class":"LiteralType","fallback":"builtins.str","value":"|b"},{".class":"LiteralType","fallback":"builtins.str","value":"=b"},{".class":"LiteralType","fallback":"builtins.str","value":"b"},{".class":"LiteralType","fallback":"builtins.str","value":"short"},{".class":"LiteralType","fallback":"builtins.str","value":"h"},{".class":"LiteralType","fallback":"builtins.str","value":"|h"},{".class":"LiteralType","fallback":"builtins.str","value":"=h"},{".class":"LiteralType","fallback":"builtins.str","value":"h"},{".class":"LiteralType","fallback":"builtins.str","value":"intc"},{".class":"LiteralType","fallback":"builtins.str","value":"i"},{".class":"LiteralType","fallback":"builtins.str","value":"|i"},{".class":"LiteralType","fallback":"builtins.str","value":"=i"},{".class":"LiteralType","fallback":"builtins.str","value":"i"},{".class":"LiteralType","fallback":"builtins.str","value":"long"},{".class":"LiteralType","fallback":"builtins.str","value":"l"},{".class":"LiteralType","fallback":"builtins.str","value":"|l"},{".class":"LiteralType","fallback":"builtins.str","value":"=l"},{".class":"LiteralType","fallback":"builtins.str","value":"l"},{".class":"LiteralType","fallback":"builtins.str","value":"longlong"},{".class":"LiteralType","fallback":"builtins.str","value":"q"},{".class":"LiteralType","fallback":"builtins.str","value":"|q"},{".class":"LiteralType","fallback":"builtins.str","value":"=q"},{".class":"LiteralType","fallback":"builtins.str","value":"q"}],"uses_pep604_syntax":false}}},"_SingleCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._SingleCodes","line":43,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"single"},{".class":"LiteralType","fallback":"builtins.str","value":"f"},{".class":"LiteralType","fallback":"builtins.str","value":"|f"},{".class":"LiteralType","fallback":"builtins.str","value":"=f"},{".class":"LiteralType","fallback":"builtins.str","value":"f"}],"uses_pep604_syntax":false}}},"_StrCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._StrCodes","line":51,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"str"},{".class":"LiteralType","fallback":"builtins.str","value":"str_"},{".class":"LiteralType","fallback":"builtins.str","value":"unicode"},{".class":"LiteralType","fallback":"builtins.str","value":"U"},{".class":"LiteralType","fallback":"builtins.str","value":"|U"},{".class":"LiteralType","fallback":"builtins.str","value":"=U"},{".class":"LiteralType","fallback":"builtins.str","value":"U"}],"uses_pep604_syntax":false}}},"_StringCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._StringCodes","line":149,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"T"},{".class":"LiteralType","fallback":"builtins.str","value":"|T"},{".class":"LiteralType","fallback":"builtins.str","value":"=T"},{".class":"LiteralType","fallback":"builtins.str","value":"T"}],"uses_pep604_syntax":false}}},"_TD64Codes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._TD64Codes","line":101,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64"},{".class":"LiteralType","fallback":"builtins.str","value":"|timedelta64"},{".class":"LiteralType","fallback":"builtins.str","value":"=timedelta64"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[Y]"},{".class":"LiteralType","fallback":"builtins.str","value":"|timedelta64[Y]"},{".class":"LiteralType","fallback":"builtins.str","value":"=timedelta64[Y]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[Y]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[M]"},{".class":"LiteralType","fallback":"builtins.str","value":"|timedelta64[M]"},{".class":"LiteralType","fallback":"builtins.str","value":"=timedelta64[M]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[M]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[W]"},{".class":"LiteralType","fallback":"builtins.str","value":"|timedelta64[W]"},{".class":"LiteralType","fallback":"builtins.str","value":"=timedelta64[W]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[W]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[D]"},{".class":"LiteralType","fallback":"builtins.str","value":"|timedelta64[D]"},{".class":"LiteralType","fallback":"builtins.str","value":"=timedelta64[D]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[D]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[h]"},{".class":"LiteralType","fallback":"builtins.str","value":"|timedelta64[h]"},{".class":"LiteralType","fallback":"builtins.str","value":"=timedelta64[h]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[h]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[m]"},{".class":"LiteralType","fallback":"builtins.str","value":"|timedelta64[m]"},{".class":"LiteralType","fallback":"builtins.str","value":"=timedelta64[m]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[m]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[s]"},{".class":"LiteralType","fallback":"builtins.str","value":"|timedelta64[s]"},{".class":"LiteralType","fallback":"builtins.str","value":"=timedelta64[s]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[s]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[ms]"},{".class":"LiteralType","fallback":"builtins.str","value":"|timedelta64[ms]"},{".class":"LiteralType","fallback":"builtins.str","value":"=timedelta64[ms]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[ms]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[us]"},{".class":"LiteralType","fallback":"builtins.str","value":"|timedelta64[us]"},{".class":"LiteralType","fallback":"builtins.str","value":"=timedelta64[us]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[us]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[ns]"},{".class":"LiteralType","fallback":"builtins.str","value":"|timedelta64[ns]"},{".class":"LiteralType","fallback":"builtins.str","value":"=timedelta64[ns]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[ns]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[ps]"},{".class":"LiteralType","fallback":"builtins.str","value":"|timedelta64[ps]"},{".class":"LiteralType","fallback":"builtins.str","value":"=timedelta64[ps]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[ps]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[fs]"},{".class":"LiteralType","fallback":"builtins.str","value":"|timedelta64[fs]"},{".class":"LiteralType","fallback":"builtins.str","value":"=timedelta64[fs]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[fs]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[as]"},{".class":"LiteralType","fallback":"builtins.str","value":"|timedelta64[as]"},{".class":"LiteralType","fallback":"builtins.str","value":"=timedelta64[as]"},{".class":"LiteralType","fallback":"builtins.str","value":"timedelta64[as]"},{".class":"LiteralType","fallback":"builtins.str","value":"m"},{".class":"LiteralType","fallback":"builtins.str","value":"|m"},{".class":"LiteralType","fallback":"builtins.str","value":"=m"},{".class":"LiteralType","fallback":"builtins.str","value":"m"},{".class":"LiteralType","fallback":"builtins.str","value":"m8"},{".class":"LiteralType","fallback":"builtins.str","value":"|m8"},{".class":"LiteralType","fallback":"builtins.str","value":"=m8"},{".class":"LiteralType","fallback":"builtins.str","value":"m8"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[Y]"},{".class":"LiteralType","fallback":"builtins.str","value":"|m8[Y]"},{".class":"LiteralType","fallback":"builtins.str","value":"=m8[Y]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[Y]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[M]"},{".class":"LiteralType","fallback":"builtins.str","value":"|m8[M]"},{".class":"LiteralType","fallback":"builtins.str","value":"=m8[M]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[M]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[W]"},{".class":"LiteralType","fallback":"builtins.str","value":"|m8[W]"},{".class":"LiteralType","fallback":"builtins.str","value":"=m8[W]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[W]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[D]"},{".class":"LiteralType","fallback":"builtins.str","value":"|m8[D]"},{".class":"LiteralType","fallback":"builtins.str","value":"=m8[D]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[D]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[h]"},{".class":"LiteralType","fallback":"builtins.str","value":"|m8[h]"},{".class":"LiteralType","fallback":"builtins.str","value":"=m8[h]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[h]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[m]"},{".class":"LiteralType","fallback":"builtins.str","value":"|m8[m]"},{".class":"LiteralType","fallback":"builtins.str","value":"=m8[m]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[m]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[s]"},{".class":"LiteralType","fallback":"builtins.str","value":"|m8[s]"},{".class":"LiteralType","fallback":"builtins.str","value":"=m8[s]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[s]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[ms]"},{".class":"LiteralType","fallback":"builtins.str","value":"|m8[ms]"},{".class":"LiteralType","fallback":"builtins.str","value":"=m8[ms]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[ms]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[us]"},{".class":"LiteralType","fallback":"builtins.str","value":"|m8[us]"},{".class":"LiteralType","fallback":"builtins.str","value":"=m8[us]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[us]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[ns]"},{".class":"LiteralType","fallback":"builtins.str","value":"|m8[ns]"},{".class":"LiteralType","fallback":"builtins.str","value":"=m8[ns]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[ns]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[ps]"},{".class":"LiteralType","fallback":"builtins.str","value":"|m8[ps]"},{".class":"LiteralType","fallback":"builtins.str","value":"=m8[ps]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[ps]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[fs]"},{".class":"LiteralType","fallback":"builtins.str","value":"|m8[fs]"},{".class":"LiteralType","fallback":"builtins.str","value":"=m8[fs]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[fs]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[as]"},{".class":"LiteralType","fallback":"builtins.str","value":"|m8[as]"},{".class":"LiteralType","fallback":"builtins.str","value":"=m8[as]"},{".class":"LiteralType","fallback":"builtins.str","value":"m8[as]"}],"uses_pep604_syntax":false}}},"_UByteCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._UByteCodes","line":34,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"ubyte"},{".class":"LiteralType","fallback":"builtins.str","value":"B"},{".class":"LiteralType","fallback":"builtins.str","value":"|B"},{".class":"LiteralType","fallback":"builtins.str","value":"=B"},{".class":"LiteralType","fallback":"builtins.str","value":"B"}],"uses_pep604_syntax":false}}},"_UInt16Codes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._UInt16Codes","line":10,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"uint16"},{".class":"LiteralType","fallback":"builtins.str","value":"u2"},{".class":"LiteralType","fallback":"builtins.str","value":"|u2"},{".class":"LiteralType","fallback":"builtins.str","value":"=u2"},{".class":"LiteralType","fallback":"builtins.str","value":"u2"}],"uses_pep604_syntax":false}}},"_UInt32Codes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._UInt32Codes","line":11,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"uint32"},{".class":"LiteralType","fallback":"builtins.str","value":"u4"},{".class":"LiteralType","fallback":"builtins.str","value":"|u4"},{".class":"LiteralType","fallback":"builtins.str","value":"=u4"},{".class":"LiteralType","fallback":"builtins.str","value":"u4"}],"uses_pep604_syntax":false}}},"_UInt64Codes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._UInt64Codes","line":12,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"uint64"},{".class":"LiteralType","fallback":"builtins.str","value":"u8"},{".class":"LiteralType","fallback":"builtins.str","value":"|u8"},{".class":"LiteralType","fallback":"builtins.str","value":"=u8"},{".class":"LiteralType","fallback":"builtins.str","value":"u8"}],"uses_pep604_syntax":false}}},"_UInt8Codes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._UInt8Codes","line":9,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"uint8"},{".class":"LiteralType","fallback":"builtins.str","value":"u1"},{".class":"LiteralType","fallback":"builtins.str","value":"|u1"},{".class":"LiteralType","fallback":"builtins.str","value":"=u1"},{".class":"LiteralType","fallback":"builtins.str","value":"u1"}],"uses_pep604_syntax":false}}},"_UIntCCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._UIntCCodes","line":36,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"uintc"},{".class":"LiteralType","fallback":"builtins.str","value":"I"},{".class":"LiteralType","fallback":"builtins.str","value":"|I"},{".class":"LiteralType","fallback":"builtins.str","value":"=I"},{".class":"LiteralType","fallback":"builtins.str","value":"I"}],"uses_pep604_syntax":false}}},"_UIntCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._UIntCodes","line":39,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UIntPCodes"}}},"_UIntPCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._UIntPCodes","line":37,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"uintp"},{".class":"LiteralType","fallback":"builtins.str","value":"uint"},{".class":"LiteralType","fallback":"builtins.str","value":"N"},{".class":"LiteralType","fallback":"builtins.str","value":"|N"},{".class":"LiteralType","fallback":"builtins.str","value":"=N"},{".class":"LiteralType","fallback":"builtins.str","value":"N"}],"uses_pep604_syntax":false}}},"_ULongCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._ULongCodes","line":38,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"ulong"},{".class":"LiteralType","fallback":"builtins.str","value":"L"},{".class":"LiteralType","fallback":"builtins.str","value":"|L"},{".class":"LiteralType","fallback":"builtins.str","value":"=L"},{".class":"LiteralType","fallback":"builtins.str","value":"L"}],"uses_pep604_syntax":false}}},"_ULongLongCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._ULongLongCodes","line":40,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"ulonglong"},{".class":"LiteralType","fallback":"builtins.str","value":"Q"},{".class":"LiteralType","fallback":"builtins.str","value":"|Q"},{".class":"LiteralType","fallback":"builtins.str","value":"=Q"},{".class":"LiteralType","fallback":"builtins.str","value":"Q"}],"uses_pep604_syntax":false}}},"_UShortCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._UShortCodes","line":35,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"ushort"},{".class":"LiteralType","fallback":"builtins.str","value":"H"},{".class":"LiteralType","fallback":"builtins.str","value":"|H"},{".class":"LiteralType","fallback":"builtins.str","value":"=H"},{".class":"LiteralType","fallback":"builtins.str","value":"H"}],"uses_pep604_syntax":false}}},"_UnsignedIntegerCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._UnsignedIntegerCodes","line":157,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"uint8"},{".class":"LiteralType","fallback":"builtins.str","value":"u1"},{".class":"LiteralType","fallback":"builtins.str","value":"|u1"},{".class":"LiteralType","fallback":"builtins.str","value":"=u1"},{".class":"LiteralType","fallback":"builtins.str","value":"u1"},{".class":"LiteralType","fallback":"builtins.str","value":"uint16"},{".class":"LiteralType","fallback":"builtins.str","value":"u2"},{".class":"LiteralType","fallback":"builtins.str","value":"|u2"},{".class":"LiteralType","fallback":"builtins.str","value":"=u2"},{".class":"LiteralType","fallback":"builtins.str","value":"u2"},{".class":"LiteralType","fallback":"builtins.str","value":"uint32"},{".class":"LiteralType","fallback":"builtins.str","value":"u4"},{".class":"LiteralType","fallback":"builtins.str","value":"|u4"},{".class":"LiteralType","fallback":"builtins.str","value":"=u4"},{".class":"LiteralType","fallback":"builtins.str","value":"u4"},{".class":"LiteralType","fallback":"builtins.str","value":"uint64"},{".class":"LiteralType","fallback":"builtins.str","value":"u8"},{".class":"LiteralType","fallback":"builtins.str","value":"|u8"},{".class":"LiteralType","fallback":"builtins.str","value":"=u8"},{".class":"LiteralType","fallback":"builtins.str","value":"u8"},{".class":"LiteralType","fallback":"builtins.str","value":"uintp"},{".class":"LiteralType","fallback":"builtins.str","value":"uint"},{".class":"LiteralType","fallback":"builtins.str","value":"N"},{".class":"LiteralType","fallback":"builtins.str","value":"|N"},{".class":"LiteralType","fallback":"builtins.str","value":"=N"},{".class":"LiteralType","fallback":"builtins.str","value":"N"},{".class":"LiteralType","fallback":"builtins.str","value":"ubyte"},{".class":"LiteralType","fallback":"builtins.str","value":"B"},{".class":"LiteralType","fallback":"builtins.str","value":"|B"},{".class":"LiteralType","fallback":"builtins.str","value":"=B"},{".class":"LiteralType","fallback":"builtins.str","value":"B"},{".class":"LiteralType","fallback":"builtins.str","value":"ushort"},{".class":"LiteralType","fallback":"builtins.str","value":"H"},{".class":"LiteralType","fallback":"builtins.str","value":"|H"},{".class":"LiteralType","fallback":"builtins.str","value":"=H"},{".class":"LiteralType","fallback":"builtins.str","value":"H"},{".class":"LiteralType","fallback":"builtins.str","value":"uintc"},{".class":"LiteralType","fallback":"builtins.str","value":"I"},{".class":"LiteralType","fallback":"builtins.str","value":"|I"},{".class":"LiteralType","fallback":"builtins.str","value":"=I"},{".class":"LiteralType","fallback":"builtins.str","value":"I"},{".class":"LiteralType","fallback":"builtins.str","value":"ulong"},{".class":"LiteralType","fallback":"builtins.str","value":"L"},{".class":"LiteralType","fallback":"builtins.str","value":"|L"},{".class":"LiteralType","fallback":"builtins.str","value":"=L"},{".class":"LiteralType","fallback":"builtins.str","value":"L"},{".class":"LiteralType","fallback":"builtins.str","value":"ulonglong"},{".class":"LiteralType","fallback":"builtins.str","value":"Q"},{".class":"LiteralType","fallback":"builtins.str","value":"|Q"},{".class":"LiteralType","fallback":"builtins.str","value":"=Q"},{".class":"LiteralType","fallback":"builtins.str","value":"Q"}],"uses_pep604_syntax":false}}},"_VoidCodes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._char_codes._VoidCodes","line":53,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"void"},{".class":"LiteralType","fallback":"builtins.str","value":"V"},{".class":"LiteralType","fallback":"builtins.str","value":"|V"},{".class":"LiteralType","fallback":"builtins.str","value":"=V"},{".class":"LiteralType","fallback":"builtins.str","value":"V"}],"uses_pep604_syntax":false}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._char_codes.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._char_codes.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._char_codes.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._char_codes.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._char_codes.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._char_codes.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_typing/_char_codes.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_char_codes.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_char_codes.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..6da772d198bddb3d94c4aa16337bcdaaabb157da --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_char_codes.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106713,"dep_lines":[1,1,1,1],"dep_prios":[5,5,30,30],"dependencies":["typing","builtins","_frozen_importlib","abc"],"hash":"7c4dcf40c0d4448ef57819c1f5d8c321bb402526","id":"numpy._typing._char_codes","ignore_all":true,"interface_hash":"2570e6edb50f112c760feaa9e3ad89e8dbce3d65","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_typing/_char_codes.py","plugin_data":null,"size":8764,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_dtype_like.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_dtype_like.data.json new file mode 100644 index 0000000000000000000000000000000000000000..2cb45e830a329258851a87e268996af73a627677 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_dtype_like.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy._typing._dtype_like","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"DTypeLike":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._dtype_like.DTypeLike","name":"DTypeLike","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}}},"Protocol":{".class":"SymbolTableNode","cross_ref":"typing.Protocol","kind":"Gdef"},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef"},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy._typing._dtype_like.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef"},"TypedDict":{".class":"SymbolTableNode","cross_ref":"typing.TypedDict","kind":"Gdef"},"_BoolCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._BoolCodes","kind":"Gdef"},"_BytesCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._BytesCodes","kind":"Gdef"},"_ComplexFloatingCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._ComplexFloatingCodes","kind":"Gdef"},"_DT64Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._DT64Codes","kind":"Gdef"},"_DTypeDict":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._typing._dtype_like._DTypeDict","name":"_DTypeDict","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy._typing._dtype_like._DTypeDict","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._typing._dtype_like","mro":["numpy._typing._dtype_like._DTypeDict","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["names",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"}],["formats",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"}],["offsets",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"}],["titles",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Sequence"}],["itemsize","builtins.int"],["aligned","builtins.bool"]],"readonly_keys":[],"required_keys":["formats","names"]}}},"_DTypeDictBase":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._typing._dtype_like._DTypeDictBase","name":"_DTypeDictBase","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy._typing._dtype_like._DTypeDictBase","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._typing._dtype_like","mro":["numpy._typing._dtype_like._DTypeDictBase","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["names",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"}],["formats",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"}]],"readonly_keys":[],"required_keys":["formats","names"]}}},"_DTypeLike":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._dtype_like._DTypeLike","name":"_DTypeLike","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}}},"_DTypeLikeBool":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._dtype_like._DTypeLikeBool","name":"_DTypeLikeBool","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}}},"_DTypeLikeBytes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._dtype_like._DTypeLikeBytes","name":"_DTypeLikeBytes","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}}},"_DTypeLikeComplex":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._dtype_like._DTypeLikeComplex","name":"_DTypeLikeComplex","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}}},"_DTypeLikeComplex_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._dtype_like._DTypeLikeComplex_co","name":"_DTypeLikeComplex_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}}},"_DTypeLikeDT64":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._dtype_like._DTypeLikeDT64","name":"_DTypeLikeDT64","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}}},"_DTypeLikeFloat":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._dtype_like._DTypeLikeFloat","name":"_DTypeLikeFloat","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}}},"_DTypeLikeInt":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._dtype_like._DTypeLikeInt","name":"_DTypeLikeInt","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}}},"_DTypeLikeNested":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._dtype_like._DTypeLikeNested","name":"_DTypeLikeNested","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}}},"_DTypeLikeObject":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._dtype_like._DTypeLikeObject","name":"_DTypeLikeObject","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}}},"_DTypeLikeStr":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._dtype_like._DTypeLikeStr","name":"_DTypeLikeStr","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}}},"_DTypeLikeTD64":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._dtype_like._DTypeLikeTD64","name":"_DTypeLikeTD64","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}}},"_DTypeLikeUInt":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._dtype_like._DTypeLikeUInt","name":"_DTypeLikeUInt","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}}},"_DTypeLikeVoid":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._dtype_like._DTypeLikeVoid","name":"_DTypeLikeVoid","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}}},"_DTypeT_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._dtype_like._DTypeT_co","name":"_DTypeT_co","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}},"_FloatingCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._FloatingCodes","kind":"Gdef"},"_NumberCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._NumberCodes","kind":"Gdef"},"_ObjectCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._ObjectCodes","kind":"Gdef"},"_ScalarT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._dtype_like._ScalarT","name":"_ScalarT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},"_SignedIntegerCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._SignedIntegerCodes","kind":"Gdef"},"_StrCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._StrCodes","kind":"Gdef"},"_SupportsDType":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[["dtype",2]],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._typing._dtype_like._SupportsDType","name":"_SupportsDType","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._dtype_like._DTypeT_co","id":1,"name":"_DTypeT_co","namespace":"numpy._typing._dtype_like._SupportsDType","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":["is_abstract","is_protocol","runtime_protocol"],"fullname":"numpy._typing._dtype_like._SupportsDType","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy._typing._dtype_like","mro":["numpy._typing._dtype_like._SupportsDType","builtins.object"],"names":{".class":"SymbolTable","dtype":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_body","is_trivial_self"],"fullname":"numpy._typing._dtype_like._SupportsDType.dtype","name":"dtype","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._dtype_like._DTypeT_co","id":1,"name":"_DTypeT_co","namespace":"numpy._typing._dtype_like._SupportsDType","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dtype of _SupportsDType","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._dtype_like._DTypeT_co","id":1,"name":"_DTypeT_co","namespace":"numpy._typing._dtype_like._SupportsDType","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._dtype_like._SupportsDType.dtype","name":"dtype","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._dtype_like._DTypeT_co","id":1,"name":"_DTypeT_co","namespace":"numpy._typing._dtype_like._SupportsDType","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dtype of _SupportsDType","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._dtype_like._DTypeT_co","id":1,"name":"_DTypeT_co","namespace":"numpy._typing._dtype_like._SupportsDType","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._dtype_like._SupportsDType.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._dtype_like._DTypeT_co","id":1,"name":"_DTypeT_co","namespace":"numpy._typing._dtype_like._SupportsDType","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_DTypeT_co"],"typeddict_type":null}},"_TD64Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._TD64Codes","kind":"Gdef"},"_UnsignedIntegerCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._UnsignedIntegerCodes","kind":"Gdef"},"_VoidCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._VoidCodes","kind":"Gdef"},"_VoidDTypeLike":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._dtype_like._VoidDTypeLike","name":"_VoidDTypeLike","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._dtype_like.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._dtype_like.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._dtype_like.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._dtype_like.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._dtype_like.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._dtype_like.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef"},"runtime_checkable":{".class":"SymbolTableNode","cross_ref":"typing.runtime_checkable","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_typing/_dtype_like.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_dtype_like.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_dtype_like.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..9cce4863fbaaa84366d3855d32e980ad845e4d86 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_dtype_like.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[13,1,2,11,1,1,1,1,1,1,1,1,1,1,1],"dep_prios":[5,5,5,10,5,30,30,30,30,30,30,30,30,30,30],"dependencies":["numpy._typing._char_codes","collections.abc","typing","numpy","builtins","_ctypes","_frozen_importlib","_typeshed","abc","ctypes","datetime","numpy._typing._nbit_base","numpy.dtypes","types","typing_extensions"],"hash":"db54b7750078a3d68b665b455ed2dd9dd469add5","id":"numpy._typing._dtype_like","ignore_all":true,"interface_hash":"b3dbbdb7c4c99a0c4412ce14056fcad3089e5898","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_typing/_dtype_like.py","plugin_data":null,"size":3762,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_extended_precision.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_extended_precision.data.json new file mode 100644 index 0000000000000000000000000000000000000000..90f38d7d53b06eb28aaacc6c721a1f448b76df72 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_extended_precision.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy._typing._extended_precision","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","_128Bit":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nbit_base._128Bit","kind":"Gdef"},"_96Bit":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nbit_base._96Bit","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._extended_precision.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._extended_precision.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._extended_precision.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._extended_precision.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._extended_precision.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._extended_precision.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"complex192":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._extended_precision.complex192","line":14,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":["numpy._typing._nbit_base._96Bit","numpy._typing._nbit_base._96Bit"],"extra_attrs":null,"type_ref":"numpy.complexfloating"}}},"complex256":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._extended_precision.complex256","line":15,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":["numpy._typing._nbit_base._128Bit","numpy._typing._nbit_base._128Bit"],"extra_attrs":null,"type_ref":"numpy.complexfloating"}}},"float128":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._extended_precision.float128","line":13,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":["numpy._typing._nbit_base._128Bit"],"extra_attrs":null,"type_ref":"numpy.floating"}}},"float96":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy._typing._extended_precision.float96","line":12,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":["numpy._typing._nbit_base._96Bit"],"extra_attrs":null,"type_ref":"numpy.floating"}}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_typing/_extended_precision.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_extended_precision.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_extended_precision.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..7af23a055968cc92d1017750066286c36f0bdea3 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_extended_precision.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[10,8,1,1,1,1,1],"dep_prios":[5,10,5,30,30,30,30],"dependencies":["numpy._typing","numpy","builtins","_frozen_importlib","abc","numpy._typing._nbit_base","typing"],"hash":"9c3cbb68874ed839f1313d26200cf1ab15c975b4","id":"numpy._typing._extended_precision","ignore_all":true,"interface_hash":"92c6f8ab4016ec1c2338c09ccad5a0234c91a7e9","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_typing/_extended_precision.py","plugin_data":null,"size":434,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_nbit.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_nbit.data.json new file mode 100644 index 0000000000000000000000000000000000000000..0e268a2c8261b59d769fbec73d8ce869f0e5e07c --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_nbit.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy._typing._nbit","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy._typing._nbit.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._nbit.TypeAlias","source_any":null,"type_of_any":3}}},"_128Bit":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nbit_base._128Bit","kind":"Gdef"},"_16Bit":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nbit_base._16Bit","kind":"Gdef"},"_32Bit":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nbit_base._32Bit","kind":"Gdef"},"_64Bit":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nbit_base._64Bit","kind":"Gdef"},"_8Bit":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nbit_base._8Bit","kind":"Gdef"},"_96Bit":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nbit_base._96Bit","kind":"Gdef"},"_NBitByte":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._nbit._NBitByte","name":"_NBitByte","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._nbit.TypeAlias","source_any":null,"type_of_any":3}}},"_NBitDouble":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._nbit._NBitDouble","name":"_NBitDouble","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._nbit.TypeAlias","source_any":null,"type_of_any":3}}},"_NBitHalf":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._nbit._NBitHalf","name":"_NBitHalf","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._nbit.TypeAlias","source_any":null,"type_of_any":3}}},"_NBitInt":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._nbit._NBitInt","name":"_NBitInt","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._nbit.TypeAlias","source_any":null,"type_of_any":3}}},"_NBitIntC":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._nbit._NBitIntC","name":"_NBitIntC","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._nbit.TypeAlias","source_any":null,"type_of_any":3}}},"_NBitIntP":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._nbit._NBitIntP","name":"_NBitIntP","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._nbit.TypeAlias","source_any":null,"type_of_any":3}}},"_NBitLong":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._nbit._NBitLong","name":"_NBitLong","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._nbit.TypeAlias","source_any":null,"type_of_any":3}}},"_NBitLongDouble":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._nbit._NBitLongDouble","name":"_NBitLongDouble","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._nbit.TypeAlias","source_any":null,"type_of_any":3}}},"_NBitLongLong":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._nbit._NBitLongLong","name":"_NBitLongLong","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._nbit.TypeAlias","source_any":null,"type_of_any":3}}},"_NBitShort":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._nbit._NBitShort","name":"_NBitShort","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._nbit.TypeAlias","source_any":null,"type_of_any":3}}},"_NBitSingle":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._nbit._NBitSingle","name":"_NBitSingle","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._nbit.TypeAlias","source_any":null,"type_of_any":3}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._nbit.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._nbit.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._nbit.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._nbit.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._nbit.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._nbit.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_typing/_nbit.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_nbit.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_nbit.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..a6a04232831259221e00c8476f7d588821b5552d --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_nbit.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106714,"dep_lines":[5,3,1,1,1],"dep_prios":[5,5,5,30,30],"dependencies":["numpy._typing._nbit_base","typing","builtins","_frozen_importlib","abc"],"hash":"3a7c5a5809f88bea21812937c3490dc59d90a6d7","id":"numpy._typing._nbit","ignore_all":true,"interface_hash":"9f3a571d3b0543187831028329ffc991c2c9b9f9","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_typing/_nbit.py","plugin_data":null,"size":632,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_nbit_base.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_nbit_base.data.json new file mode 100644 index 0000000000000000000000000000000000000000..837b9bfa54e94badcc488dd3c339bdd863700133 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_nbit_base.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy._typing._nbit_base","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","NBitBase":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._typing._nbit_base.NBitBase","name":"NBitBase","type_vars":[]},"deletable_attributes":[],"deprecated":"class numpy._typing._nbit_base.NBitBase is deprecated: `NBitBase` is deprecated and will be removed from numpy.typing in the future. Use `@typing.overload` or a `TypeVar` with a scalar-type as upper bound, instead. (deprecated in NumPy 2.3)","flags":["is_final"],"fullname":"numpy._typing._nbit_base.NBitBase","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._typing._nbit_base","mro":["numpy._typing._nbit_base.NBitBase","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._nbit_base.NBitBase.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy._typing._nbit_base.NBitBase","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_128Bit":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy._typing._nbit_base._256Bit"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._typing._nbit_base._128Bit","name":"_128Bit","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_final"],"fullname":"numpy._typing._nbit_base._128Bit","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._typing._nbit_base","mro":["numpy._typing._nbit_base._128Bit","numpy._typing._nbit_base._256Bit","numpy._typing._nbit_base.NBitBase","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._nbit_base._128Bit.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy._typing._nbit_base._128Bit","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_16Bit":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy._typing._nbit_base._32Bit"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._typing._nbit_base._16Bit","name":"_16Bit","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_final"],"fullname":"numpy._typing._nbit_base._16Bit","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._typing._nbit_base","mro":["numpy._typing._nbit_base._16Bit","numpy._typing._nbit_base._32Bit","numpy._typing._nbit_base._64Bit","numpy._typing._nbit_base._80Bit","numpy._typing._nbit_base._96Bit","numpy._typing._nbit_base._128Bit","numpy._typing._nbit_base._256Bit","numpy._typing._nbit_base.NBitBase","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._nbit_base._16Bit.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy._typing._nbit_base._16Bit","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_256Bit":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy._typing._nbit_base.NBitBase"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._typing._nbit_base._256Bit","name":"_256Bit","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_final"],"fullname":"numpy._typing._nbit_base._256Bit","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._typing._nbit_base","mro":["numpy._typing._nbit_base._256Bit","numpy._typing._nbit_base.NBitBase","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._nbit_base._256Bit.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy._typing._nbit_base._256Bit","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_32Bit":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy._typing._nbit_base._64Bit"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._typing._nbit_base._32Bit","name":"_32Bit","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_final"],"fullname":"numpy._typing._nbit_base._32Bit","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._typing._nbit_base","mro":["numpy._typing._nbit_base._32Bit","numpy._typing._nbit_base._64Bit","numpy._typing._nbit_base._80Bit","numpy._typing._nbit_base._96Bit","numpy._typing._nbit_base._128Bit","numpy._typing._nbit_base._256Bit","numpy._typing._nbit_base.NBitBase","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._nbit_base._32Bit.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy._typing._nbit_base._32Bit","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_64Bit":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy._typing._nbit_base._80Bit"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._typing._nbit_base._64Bit","name":"_64Bit","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_final"],"fullname":"numpy._typing._nbit_base._64Bit","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._typing._nbit_base","mro":["numpy._typing._nbit_base._64Bit","numpy._typing._nbit_base._80Bit","numpy._typing._nbit_base._96Bit","numpy._typing._nbit_base._128Bit","numpy._typing._nbit_base._256Bit","numpy._typing._nbit_base.NBitBase","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._nbit_base._64Bit.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy._typing._nbit_base._64Bit","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_80Bit":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy._typing._nbit_base._96Bit"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._typing._nbit_base._80Bit","name":"_80Bit","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_final"],"fullname":"numpy._typing._nbit_base._80Bit","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._typing._nbit_base","mro":["numpy._typing._nbit_base._80Bit","numpy._typing._nbit_base._96Bit","numpy._typing._nbit_base._128Bit","numpy._typing._nbit_base._256Bit","numpy._typing._nbit_base.NBitBase","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._nbit_base._80Bit.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy._typing._nbit_base._80Bit","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_8Bit":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy._typing._nbit_base._16Bit"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._typing._nbit_base._8Bit","name":"_8Bit","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_final"],"fullname":"numpy._typing._nbit_base._8Bit","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._typing._nbit_base","mro":["numpy._typing._nbit_base._8Bit","numpy._typing._nbit_base._16Bit","numpy._typing._nbit_base._32Bit","numpy._typing._nbit_base._64Bit","numpy._typing._nbit_base._80Bit","numpy._typing._nbit_base._96Bit","numpy._typing._nbit_base._128Bit","numpy._typing._nbit_base._256Bit","numpy._typing._nbit_base.NBitBase","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._nbit_base._8Bit.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy._typing._nbit_base._8Bit","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_96Bit":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy._typing._nbit_base._128Bit"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._typing._nbit_base._96Bit","name":"_96Bit","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_final"],"fullname":"numpy._typing._nbit_base._96Bit","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._typing._nbit_base","mro":["numpy._typing._nbit_base._96Bit","numpy._typing._nbit_base._128Bit","numpy._typing._nbit_base._256Bit","numpy._typing._nbit_base.NBitBase","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._nbit_base._96Bit.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy._typing._nbit_base._96Bit","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._nbit_base.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._nbit_base.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._nbit_base.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._nbit_base.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._nbit_base.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._nbit_base.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"deprecated":{".class":"SymbolTableNode","cross_ref":"typing_extensions.deprecated","kind":"Gdef","module_hidden":true,"module_public":false},"final":{".class":"SymbolTableNode","cross_ref":"typing.final","kind":"Gdef","module_hidden":true,"module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_typing/_nbit_base.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_nbit_base.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_nbit_base.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..6207dfdbd266ca31a716f093a7bbd7e2651ee7d7 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_nbit_base.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106713,"dep_lines":[5,7,1,1,1],"dep_prios":[5,5,5,30,30],"dependencies":["typing","typing_extensions","builtins","_frozen_importlib","abc"],"hash":"6c9f84c1849ade68ca29f8bfbd7b56e590eab959","id":"numpy._typing._nbit_base","ignore_all":true,"interface_hash":"f227924d60bb0a5a2b9a26625b21804f56ce5002","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_typing/_nbit_base.pyi","plugin_data":null,"size":740,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_nested_sequence.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_nested_sequence.data.json new file mode 100644 index 0000000000000000000000000000000000000000..f1e58e1b92a000ddfa3b3d8b8b3d810945d4f390 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_nested_sequence.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy._typing._nested_sequence","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_public":false},"Iterator":{".class":"SymbolTableNode","cross_ref":"typing.Iterator","kind":"Gdef","module_public":false},"Protocol":{".class":"SymbolTableNode","cross_ref":"typing.Protocol","kind":"Gdef","module_public":false},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef","module_public":false},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_public":false},"_NestedSequence":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[["__contains__",2],["__getitem__",2],["__iter__",2],["__len__",2],["__reversed__",2],["count",2],["index",2]],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._typing._nested_sequence._NestedSequence","name":"_NestedSequence","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._nested_sequence._T_co","id":1,"name":"_T_co","namespace":"numpy._typing._nested_sequence._NestedSequence","upper_bound":"builtins.object","values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":["is_abstract","is_protocol","runtime_protocol"],"fullname":"numpy._typing._nested_sequence._NestedSequence","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy._typing._nested_sequence","mro":["numpy._typing._nested_sequence._NestedSequence","builtins.object"],"names":{".class":"SymbolTable","__contains__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_body","is_trivial_self"],"fullname":"numpy._typing._nested_sequence._NestedSequence.__contains__","name":"__contains__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._nested_sequence._T_co","id":1,"name":"_T_co","namespace":"numpy._typing._nested_sequence._NestedSequence","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__contains__ of _NestedSequence","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__getitem__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_body","is_trivial_self"],"fullname":"numpy._typing._nested_sequence._NestedSequence.__getitem__","name":"__getitem__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._nested_sequence._T_co","id":1,"name":"_T_co","namespace":"numpy._typing._nested_sequence._NestedSequence","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of _NestedSequence","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._nested_sequence._T_co","id":1,"name":"_T_co","namespace":"numpy._typing._nested_sequence._NestedSequence","upper_bound":"builtins.object","values":[],"variance":1},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._nested_sequence._T_co","id":1,"name":"_T_co","namespace":"numpy._typing._nested_sequence._NestedSequence","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__iter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_body","is_trivial_self"],"fullname":"numpy._typing._nested_sequence._NestedSequence.__iter__","name":"__iter__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._nested_sequence._T_co","id":1,"name":"_T_co","namespace":"numpy._typing._nested_sequence._NestedSequence","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iter__ of _NestedSequence","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._nested_sequence._T_co","id":1,"name":"_T_co","namespace":"numpy._typing._nested_sequence._NestedSequence","upper_bound":"builtins.object","values":[],"variance":1},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._nested_sequence._T_co","id":1,"name":"_T_co","namespace":"numpy._typing._nested_sequence._NestedSequence","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Iterator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__len__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_body","is_trivial_self"],"fullname":"numpy._typing._nested_sequence._NestedSequence.__len__","name":"__len__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._nested_sequence._T_co","id":1,"name":"_T_co","namespace":"numpy._typing._nested_sequence._NestedSequence","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__len__ of _NestedSequence","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__reversed__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_body","is_trivial_self"],"fullname":"numpy._typing._nested_sequence._NestedSequence.__reversed__","name":"__reversed__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._nested_sequence._T_co","id":1,"name":"_T_co","namespace":"numpy._typing._nested_sequence._NestedSequence","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__reversed__ of _NestedSequence","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._nested_sequence._T_co","id":1,"name":"_T_co","namespace":"numpy._typing._nested_sequence._NestedSequence","upper_bound":"builtins.object","values":[],"variance":1},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._nested_sequence._T_co","id":1,"name":"_T_co","namespace":"numpy._typing._nested_sequence._NestedSequence","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Iterator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"count":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_body","is_trivial_self"],"fullname":"numpy._typing._nested_sequence._NestedSequence.count","name":"count","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._nested_sequence._T_co","id":1,"name":"_T_co","namespace":"numpy._typing._nested_sequence._NestedSequence","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count of _NestedSequence","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"index":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_body","is_trivial_self"],"fullname":"numpy._typing._nested_sequence._NestedSequence.index","name":"index","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._nested_sequence._T_co","id":1,"name":"_T_co","namespace":"numpy._typing._nested_sequence._NestedSequence","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"index of _NestedSequence","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._nested_sequence._NestedSequence.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._nested_sequence._T_co","id":1,"name":"_T_co","namespace":"numpy._typing._nested_sequence._NestedSequence","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_T_co"],"typeddict_type":null}},"_T_co":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._nested_sequence._T_co","name":"_T_co","upper_bound":"builtins.object","values":[],"variance":1}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy._typing._nested_sequence.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._nested_sequence.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._nested_sequence.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._nested_sequence.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._nested_sequence.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._nested_sequence.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._nested_sequence.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"runtime_checkable":{".class":"SymbolTableNode","cross_ref":"typing.runtime_checkable","kind":"Gdef","module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_typing/_nested_sequence.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_nested_sequence.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_nested_sequence.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..30407eeed8551ea131b6d617703efdcac8edcafa --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_nested_sequence.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106713,"dep_lines":[6,3,1,1,1],"dep_prios":[25,5,5,30,30],"dependencies":["collections.abc","typing","builtins","_frozen_importlib","abc"],"hash":"929716de91657bad1144d2a213a1c4276d6eb117","id":"numpy._typing._nested_sequence","ignore_all":true,"interface_hash":"2674f45b7dc5e87b43fb9dd83035fe79dcdd073f","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_typing/_nested_sequence.py","plugin_data":null,"size":2505,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_scalars.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_scalars.data.json new file mode 100644 index 0000000000000000000000000000000000000000..e92884dc21dc6c46624626fdd9f40bc11af26c45 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_scalars.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy._typing._scalars","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy._typing._scalars.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}}},"_BoolLike_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._scalars._BoolLike_co","name":"_BoolLike_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}}},"_CharLike_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._scalars._CharLike_co","name":"_CharLike_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}}},"_ComplexLike_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._scalars._ComplexLike_co","name":"_ComplexLike_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}}},"_FloatLike_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._scalars._FloatLike_co","name":"_FloatLike_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}}},"_IntLike_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._scalars._IntLike_co","name":"_IntLike_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}}},"_NumberLike_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._scalars._NumberLike_co","name":"_NumberLike_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}}},"_ScalarLike_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._scalars._ScalarLike_co","name":"_ScalarLike_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}}},"_TD64Like_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._scalars._TD64Like_co","name":"_TD64Like_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}}},"_UIntLike_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._scalars._UIntLike_co","name":"_UIntLike_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}}},"_VoidLike_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._scalars._VoidLike_co","name":"_VoidLike_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._scalars.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._scalars.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._scalars.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._scalars.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._scalars.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._scalars.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_typing/_scalars.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_scalars.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_scalars.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..7384144333f88321630a70453ee372a95b8de814 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_scalars.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,3,1,1,1,1,1,1,1],"dep_prios":[5,10,5,30,30,30,30,30,30],"dependencies":["typing","numpy","builtins","_frozen_importlib","_typeshed","abc","datetime","numpy._typing._nbit_base","typing_extensions"],"hash":"c5b595896aa65bbd1402a1c52b4d43c97f27cee7","id":"numpy._typing._scalars","ignore_all":true,"interface_hash":"2562986e42635fe2f92bd7a80a20ef5b6ad23f2b","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_typing/_scalars.py","plugin_data":null,"size":944,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_shape.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_shape.data.json new file mode 100644 index 0000000000000000000000000000000000000000..512eccfe5a620bda48aa80e2b448229fec35200b --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_shape.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy._typing._shape","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef"},"SupportsIndex":{".class":"SymbolTableNode","cross_ref":"typing.SupportsIndex","kind":"Gdef"},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy._typing._shape.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}}},"_AnyShape":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._shape._AnyShape","name":"_AnyShape","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}}},"_Shape":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._shape._Shape","name":"_Shape","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}}},"_ShapeLike":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._shape._ShapeLike","name":"_ShapeLike","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._shape.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._shape.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._shape.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._shape.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._shape.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._shape.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_typing/_shape.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_shape.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_shape.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..5a0d6ca567bf926c57b11e8bb8daef751f174811 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_shape.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106713,"dep_lines":[1,2,1,1,1],"dep_prios":[5,5,5,30,30],"dependencies":["collections.abc","typing","builtins","_frozen_importlib","abc"],"hash":"2dde92a4c6d2608694c0fe5f208d2438300d13c2","id":"numpy._typing._shape","ignore_all":true,"interface_hash":"0e1e1d6ed07c5ee95d6a4e1bbdb582dacb99a2ee","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_typing/_shape.py","plugin_data":null,"size":275,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_ufunc.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_ufunc.data.json new file mode 100644 index 0000000000000000000000000000000000000000..3af31c75074543ff484e9a5e0a3ffd4fa4324580 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_ufunc.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy._typing._ufunc","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"DTypeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like.DTypeLike","kind":"Gdef","module_hidden":true,"module_public":false},"Generic":{".class":"SymbolTableNode","cross_ref":"typing.Generic","kind":"Gdef","module_hidden":true,"module_public":false},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"LiteralString":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc.LiteralString","name":"LiteralString","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3}}},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"NoReturn":{".class":"SymbolTableNode","cross_ref":"typing.NoReturn","kind":"Gdef","module_hidden":true,"module_public":false},"Protocol":{".class":"SymbolTableNode","cross_ref":"typing.Protocol","kind":"Gdef","module_hidden":true,"module_public":false},"SupportsIndex":{".class":"SymbolTableNode","cross_ref":"typing.SupportsIndex","kind":"Gdef","module_hidden":true,"module_public":false},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"TypedDict":{".class":"SymbolTableNode","cross_ref":"typing.TypedDict","kind":"Gdef","module_hidden":true,"module_public":false},"Unpack":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc.Unpack","name":"Unpack","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}}},"_2PTuple":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._ufunc._2PTuple","name":"_2PTuple","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}}},"_2Tuple":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._ufunc._2Tuple","name":"_2Tuple","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}}},"_3PTuple":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._ufunc._3PTuple","name":"_3PTuple","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}}},"_3Tuple":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._ufunc._3Tuple","name":"_3Tuple","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}}},"_4PTuple":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._ufunc._4PTuple","name":"_4PTuple","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}}},"_4Tuple":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy._typing._ufunc._4Tuple","name":"_4Tuple","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}}},"_ArrayLikeBool_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeBool_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeInt_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeInt_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","name":"_ArrayT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}},"_CastingKind":{".class":"SymbolTableNode","cross_ref":"numpy._CastingKind","kind":"Gdef","module_hidden":true,"module_public":false},"_GUFunc_Nin2_Nout1":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy.ufunc"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","name":"_GUFunc_Nin2_Nout1","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._Signature","id":4,"name":"_Signature","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._typing._ufunc","mro":["numpy._typing._ufunc._GUFunc_Nin2_Nout1","numpy.ufunc","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._typing._ufunc._GUFunc_Nin2_Nout1.__call__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,5,5,5,5,5,5],"arg_names":["self",null,null,"out","casting","order","dtype","subok","signature","axes"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._GUFunc_Nin2_Nout1.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,5,5,5,5,5,5],"arg_names":["self",null,null,"out","casting","order","dtype","subok","signature","axes"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._Signature","id":4,"name":"_Signature","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._GUFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _GUFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._GUFunc_Nin2_Nout1.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,5,5,5,5,5,5],"arg_names":["self",null,null,"out","casting","order","dtype","subok","signature","axes"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._Signature","id":4,"name":"_Signature","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._GUFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _GUFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,5,5,5,5,5,5],"arg_names":["self",null,null,"out","casting","order","dtype","subok","signature","axes"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._GUFunc_Nin2_Nout1.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,5,5,5,5,5,5],"arg_names":["self",null,null,"out","casting","order","dtype","subok","signature","axes"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._Signature","id":4,"name":"_Signature","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._GUFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _GUFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._GUFunc_Nin2_Nout1.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,5,5,5,5,5,5],"arg_names":["self",null,null,"out","casting","order","dtype","subok","signature","axes"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._Signature","id":4,"name":"_Signature","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._GUFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _GUFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,1,5,5,5,5,5,5],"arg_names":["self",null,null,"out","casting","order","dtype","subok","signature","axes"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._Signature","id":4,"name":"_Signature","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._GUFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _GUFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,5,5,5,5,5,5],"arg_names":["self",null,null,"out","casting","order","dtype","subok","signature","axes"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._Signature","id":4,"name":"_Signature","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._GUFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _GUFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"__name__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._GUFunc_Nin2_Nout1.__name__","name":"__name__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._Signature","id":4,"name":"_Signature","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._GUFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__name__ of _GUFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._GUFunc_Nin2_Nout1.__name__","name":"__name__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._Signature","id":4,"name":"_Signature","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._GUFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__name__ of _GUFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__qualname__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._GUFunc_Nin2_Nout1.__qualname__","name":"__qualname__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._Signature","id":4,"name":"_Signature","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._GUFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__qualname__ of _GUFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._GUFunc_Nin2_Nout1.__qualname__","name":"__qualname__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._Signature","id":4,"name":"_Signature","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._GUFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__qualname__ of _GUFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"accumulate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._GUFunc_Nin2_Nout1.accumulate","name":"accumulate","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._Signature","id":4,"name":"_Signature","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._GUFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"accumulate of _GUFunc_Nin2_Nout1","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"at":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._GUFunc_Nin2_Nout1.at","name":"at","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._Signature","id":4,"name":"_Signature","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._GUFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"at of _GUFunc_Nin2_Nout1","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"identity":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._GUFunc_Nin2_Nout1.identity","name":"identity","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._Signature","id":4,"name":"_Signature","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._GUFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"identity of _GUFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._GUFunc_Nin2_Nout1.identity","name":"identity","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._Signature","id":4,"name":"_Signature","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._GUFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"identity of _GUFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"nargs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._GUFunc_Nin2_Nout1.nargs","name":"nargs","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._Signature","id":4,"name":"_Signature","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._GUFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nargs of _GUFunc_Nin2_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._GUFunc_Nin2_Nout1.nargs","name":"nargs","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._Signature","id":4,"name":"_Signature","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._GUFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nargs of _GUFunc_Nin2_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"nin":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._GUFunc_Nin2_Nout1.nin","name":"nin","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._Signature","id":4,"name":"_Signature","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._GUFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nin of _GUFunc_Nin2_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._GUFunc_Nin2_Nout1.nin","name":"nin","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._Signature","id":4,"name":"_Signature","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._GUFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nin of _GUFunc_Nin2_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"nout":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._GUFunc_Nin2_Nout1.nout","name":"nout","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._Signature","id":4,"name":"_Signature","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._GUFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nout of _GUFunc_Nin2_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._GUFunc_Nin2_Nout1.nout","name":"nout","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._Signature","id":4,"name":"_Signature","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._GUFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nout of _GUFunc_Nin2_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"ntypes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._GUFunc_Nin2_Nout1.ntypes","name":"ntypes","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._Signature","id":4,"name":"_Signature","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._GUFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ntypes of _GUFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._GUFunc_Nin2_Nout1.ntypes","name":"ntypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._Signature","id":4,"name":"_Signature","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._GUFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ntypes of _GUFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"outer":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._GUFunc_Nin2_Nout1.outer","name":"outer","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._Signature","id":4,"name":"_Signature","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._GUFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _GUFunc_Nin2_Nout1","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"reduce":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._GUFunc_Nin2_Nout1.reduce","name":"reduce","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._Signature","id":4,"name":"_Signature","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._GUFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduce of _GUFunc_Nin2_Nout1","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"reduceat":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._GUFunc_Nin2_Nout1.reduceat","name":"reduceat","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._Signature","id":4,"name":"_Signature","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._GUFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduceat of _GUFunc_Nin2_Nout1","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"signature":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._GUFunc_Nin2_Nout1.signature","name":"signature","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._Signature","id":4,"name":"_Signature","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._GUFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"signature of _GUFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._Signature","id":4,"name":"_Signature","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._GUFunc_Nin2_Nout1.signature","name":"signature","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._Signature","id":4,"name":"_Signature","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._GUFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"signature of _GUFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._Signature","id":4,"name":"_Signature","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._GUFunc_Nin2_Nout1.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._Signature","id":4,"name":"_Signature","namespace":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._GUFunc_Nin2_Nout1"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_NameType","_NTypes","_IDType","_Signature"],"typeddict_type":null}},"_IDType":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","name":"_IDType","upper_bound":"builtins.object","values":[],"variance":1}},"_NIn":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","name":"_NIn","upper_bound":"builtins.int","values":[],"variance":1}},"_NOut":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NOut","name":"_NOut","upper_bound":"builtins.int","values":[],"variance":1}},"_NTypes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","name":"_NTypes","upper_bound":"builtins.int","values":[],"variance":1}},"_NameType":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","name":"_NameType","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}},"_OrderKACF":{".class":"SymbolTableNode","cross_ref":"numpy._OrderKACF","kind":"Gdef","module_hidden":true,"module_public":false},"_PyFunc_Kwargs_Nargs2":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._typing._ufunc._PyFunc_Kwargs_Nargs2","name":"_PyFunc_Kwargs_Nargs2","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy._typing._ufunc._PyFunc_Kwargs_Nargs2","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._typing._ufunc","mro":["numpy._typing._ufunc._PyFunc_Kwargs_Nargs2","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["where",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],["casting",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],["order",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],["dtype",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}],["subok","builtins.bool"],["signature",{".class":"UnionType","items":["builtins.str",{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}]],"readonly_keys":[],"required_keys":[]}}},"_PyFunc_Kwargs_Nargs3":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._typing._ufunc._PyFunc_Kwargs_Nargs3","name":"_PyFunc_Kwargs_Nargs3","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy._typing._ufunc._PyFunc_Kwargs_Nargs3","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._typing._ufunc","mro":["numpy._typing._ufunc._PyFunc_Kwargs_Nargs3","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["where",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],["casting",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],["order",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],["dtype",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}],["subok","builtins.bool"],["signature",{".class":"UnionType","items":["builtins.str",{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}]],"readonly_keys":[],"required_keys":[]}}},"_PyFunc_Kwargs_Nargs3P":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._typing._ufunc._PyFunc_Kwargs_Nargs3P","name":"_PyFunc_Kwargs_Nargs3P","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy._typing._ufunc._PyFunc_Kwargs_Nargs3P","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._typing._ufunc","mro":["numpy._typing._ufunc._PyFunc_Kwargs_Nargs3P","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["where",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],["casting",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],["order",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],["dtype",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}],["subok","builtins.bool"],["signature",{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}]],"readonly_keys":[],"required_keys":[]}}},"_PyFunc_Kwargs_Nargs4P":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._typing._ufunc._PyFunc_Kwargs_Nargs4P","name":"_PyFunc_Kwargs_Nargs4P","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy._typing._ufunc._PyFunc_Kwargs_Nargs4P","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._typing._ufunc","mro":["numpy._typing._ufunc._PyFunc_Kwargs_Nargs4P","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["where",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],["casting",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],["order",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],["dtype",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}],["subok","builtins.bool"],["signature",{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}]],"readonly_keys":[],"required_keys":[]}}},"_PyFunc_Nin1P_Nout2P":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy.ufunc"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","name":"_PyFunc_Nin1P_Nout2P","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NOut","id":4,"name":"_NOut","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._typing._ufunc","mro":["numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","numpy.ufunc","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P.__call__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,2,5,4],"arg_names":[null,null,"xs","out","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,2,5,4],"arg_names":[null,null,"xs","out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NOut","id":4,"name":"_NOut","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin1P_Nout2P","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,2,5,4],"arg_names":[null,null,"xs","out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NOut","id":4,"name":"_NOut","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin1P_Nout2P","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,2,5,4],"arg_names":[null,null,"xs","out","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,2,5,4],"arg_names":[null,null,"xs","out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NOut","id":4,"name":"_NOut","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin1P_Nout2P","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,2,5,4],"arg_names":[null,null,"xs","out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NOut","id":4,"name":"_NOut","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin1P_Nout2P","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,2,3,4],"arg_names":[null,null,"xs","out","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,2,3,4],"arg_names":[null,null,"xs","out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NOut","id":4,"name":"_NOut","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin1P_Nout2P","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,2,3,4],"arg_names":[null,null,"xs","out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NOut","id":4,"name":"_NOut","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin1P_Nout2P","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,2,5,4],"arg_names":[null,null,"xs","out","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,2,5,4],"arg_names":[null,null,"xs","out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NOut","id":4,"name":"_NOut","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P"},{".class":"UnionType","items":["numpy._typing._ufunc._SupportsArrayUFunc",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._ufunc._SupportsArrayUFunc",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin1P_Nout2P","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,2,5,4],"arg_names":[null,null,"xs","out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NOut","id":4,"name":"_NOut","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P"},{".class":"UnionType","items":["numpy._typing._ufunc._SupportsArrayUFunc",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._ufunc._SupportsArrayUFunc",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin1P_Nout2P","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,2,5,4],"arg_names":[null,null,"xs","out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NOut","id":4,"name":"_NOut","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin1P_Nout2P","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,2,5,4],"arg_names":[null,null,"xs","out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NOut","id":4,"name":"_NOut","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin1P_Nout2P","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,2,3,4],"arg_names":[null,null,"xs","out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NOut","id":4,"name":"_NOut","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin1P_Nout2P","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,2,5,4],"arg_names":[null,null,"xs","out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NOut","id":4,"name":"_NOut","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P"},{".class":"UnionType","items":["numpy._typing._ufunc._SupportsArrayUFunc",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._ufunc._SupportsArrayUFunc",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin1P_Nout2P","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"accumulate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P.accumulate","name":"accumulate","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NOut","id":4,"name":"_NOut","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"accumulate of _PyFunc_Nin1P_Nout2P","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"at":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P.at","name":"at","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NOut","id":4,"name":"_NOut","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"at of _PyFunc_Nin1P_Nout2P","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"identity":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P.identity","name":"identity","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NOut","id":4,"name":"_NOut","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"identity of _PyFunc_Nin1P_Nout2P","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P.identity","name":"identity","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NOut","id":4,"name":"_NOut","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"identity of _PyFunc_Nin1P_Nout2P","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"nin":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P.nin","name":"nin","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NOut","id":4,"name":"_NOut","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nin of _PyFunc_Nin1P_Nout2P","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P.nin","name":"nin","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NOut","id":4,"name":"_NOut","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nin of _PyFunc_Nin1P_Nout2P","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"nout":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P.nout","name":"nout","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NOut","id":4,"name":"_NOut","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nout of _PyFunc_Nin1P_Nout2P","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NOut","id":4,"name":"_NOut","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P.nout","name":"nout","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NOut","id":4,"name":"_NOut","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nout of _PyFunc_Nin1P_Nout2P","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NOut","id":4,"name":"_NOut","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"ntypes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P.ntypes","name":"ntypes","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NOut","id":4,"name":"_NOut","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ntypes of _PyFunc_Nin1P_Nout2P","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P.ntypes","name":"ntypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NOut","id":4,"name":"_NOut","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ntypes of _PyFunc_Nin1P_Nout2P","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"outer":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P.outer","name":"outer","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NOut","id":4,"name":"_NOut","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _PyFunc_Nin1P_Nout2P","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"reduce":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P.reduce","name":"reduce","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NOut","id":4,"name":"_NOut","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduce of _PyFunc_Nin1P_Nout2P","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"reduceat":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P.reduceat","name":"reduceat","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NOut","id":4,"name":"_NOut","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduceat of _PyFunc_Nin1P_Nout2P","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"signature":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P.signature","name":"signature","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NOut","id":4,"name":"_NOut","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"signature of _PyFunc_Nin1P_Nout2P","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P.signature","name":"signature","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NOut","id":4,"name":"_NOut","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"signature of _PyFunc_Nin1P_Nout2P","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NOut","id":4,"name":"_NOut","namespace":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1P_Nout2P"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_ReturnType_co","_IDType","_NIn","_NOut"],"typeddict_type":null}},"_PyFunc_Nin1_Nout1":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy.ufunc"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","name":"_PyFunc_Nin1_Nout1","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._typing._ufunc","mro":["numpy._typing._ufunc._PyFunc_Nin1_Nout1","numpy.ufunc","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.__call__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,4],"arg_names":[null,null,"out","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,4],"arg_names":[null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin1_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,4],"arg_names":[null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin1_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,4],"arg_names":[null,null,"out","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,4],"arg_names":[null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin1_Nout1","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,4],"arg_names":[null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin1_Nout1","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,4],"arg_names":[null,null,"out","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,4],"arg_names":[null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"TupleType","implicit":false,"items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin1_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,4],"arg_names":[null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"TupleType","implicit":false,"items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin1_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,4],"arg_names":[null,null,"out","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,4],"arg_names":[null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1"},"numpy._typing._ufunc._SupportsArrayUFunc",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin1_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,4],"arg_names":[null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1"},"numpy._typing._ufunc._SupportsArrayUFunc",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin1_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,4],"arg_names":[null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin1_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,4],"arg_names":[null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin1_Nout1","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,4],"arg_names":[null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"TupleType","implicit":false,"items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin1_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,4],"arg_names":[null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1"},"numpy._typing._ufunc._SupportsArrayUFunc",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin1_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"accumulate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.accumulate","name":"accumulate","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"accumulate of _PyFunc_Nin1_Nout1","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"at":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":[null,null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.at","name":"at","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1"},"numpy._typing._ufunc._SupportsArrayUFunc",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"at of _PyFunc_Nin1_Nout1","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"identity":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.identity","name":"identity","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"identity of _PyFunc_Nin1_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.identity","name":"identity","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"identity of _PyFunc_Nin1_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"nargs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.nargs","name":"nargs","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nargs of _PyFunc_Nin1_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.nargs","name":"nargs","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nargs of _PyFunc_Nin1_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"nin":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.nin","name":"nin","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nin of _PyFunc_Nin1_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.nin","name":"nin","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nin of _PyFunc_Nin1_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"nout":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.nout","name":"nout","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nout of _PyFunc_Nin1_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.nout","name":"nout","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nout of _PyFunc_Nin1_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"ntypes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.ntypes","name":"ntypes","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ntypes of _PyFunc_Nin1_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.ntypes","name":"ntypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ntypes of _PyFunc_Nin1_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"outer":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.outer","name":"outer","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _PyFunc_Nin1_Nout1","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"reduce":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.reduce","name":"reduce","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduce of _PyFunc_Nin1_Nout1","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"reduceat":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.reduceat","name":"reduceat","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduceat of _PyFunc_Nin1_Nout1","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"signature":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.signature","name":"signature","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"signature of _PyFunc_Nin1_Nout1","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.signature","name":"signature","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"signature of _PyFunc_Nin1_Nout1","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._PyFunc_Nin1_Nout1.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin1_Nout1"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_ReturnType_co","_IDType"],"typeddict_type":null}},"_PyFunc_Nin2_Nout1":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy.ufunc"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","name":"_PyFunc_Nin2_Nout1","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._typing._ufunc","mro":["numpy._typing._ufunc._PyFunc_Nin2_Nout1","numpy.ufunc","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.__call__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,4],"arg_names":[null,null,null,"out","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":[null,null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":[null,null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,4],"arg_names":[null,null,null,"out","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":[null,null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin2_Nout1","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":[null,null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin2_Nout1","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,4],"arg_names":[null,null,null,"out","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,4],"arg_names":[null,null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"TupleType","implicit":false,"items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,4],"arg_names":[null,null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"TupleType","implicit":false,"items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,4],"arg_names":[null,null,null,"out","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":[null,null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},"numpy._typing._ufunc._SupportsArrayUFunc",{".class":"UnionType","items":["numpy._typing._ufunc._SupportsArrayUFunc",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":[null,null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},"numpy._typing._ufunc._SupportsArrayUFunc",{".class":"UnionType","items":["numpy._typing._ufunc._SupportsArrayUFunc",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,4],"arg_names":[null,null,null,"out","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":[null,null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._typing._ufunc._SupportsArrayUFunc",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":[null,null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._typing._ufunc._SupportsArrayUFunc",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":[null,null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":[null,null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin2_Nout1","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,4],"arg_names":[null,null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"TupleType","implicit":false,"items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":[null,null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},"numpy._typing._ufunc._SupportsArrayUFunc",{".class":"UnionType","items":["numpy._typing._ufunc._SupportsArrayUFunc",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,4],"arg_names":[null,null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._typing._ufunc._SupportsArrayUFunc",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"accumulate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.accumulate","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0],"arg_names":[null,null,null,null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.accumulate","name":"accumulate","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":[null,null,null,null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.accumulate#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"accumulate of _PyFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.accumulate#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.accumulate#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.accumulate","name":"accumulate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":[null,null,null,null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.accumulate#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"accumulate of _PyFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.accumulate#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.accumulate#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,3],"arg_names":["self","array","axis","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.accumulate","name":"accumulate","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,3],"arg_names":["self","array","axis","dtype","out"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.accumulate#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"TupleType","implicit":false,"items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.accumulate#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"accumulate of _PyFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.accumulate#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.accumulate#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.accumulate","name":"accumulate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,3],"arg_names":["self","array","axis","dtype","out"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.accumulate#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"TupleType","implicit":false,"items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.accumulate#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"accumulate of _PyFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.accumulate#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.accumulate#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":[null,"array","axis","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.accumulate","name":"accumulate","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":[null,"array","axis","dtype","out"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"accumulate of _PyFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.accumulate","name":"accumulate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":[null,"array","axis","dtype","out"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"accumulate of _PyFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":[null,null,null,null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.accumulate#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"accumulate of _PyFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.accumulate#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.accumulate#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,3],"arg_names":["self","array","axis","dtype","out"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.accumulate#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"TupleType","implicit":false,"items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.accumulate#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"accumulate of _PyFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.accumulate#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.accumulate#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":[null,"array","axis","dtype","out"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"accumulate of _PyFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"at":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":[null,null,null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.at","name":"at","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,null,null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},"numpy._typing._ufunc._SupportsArrayUFunc",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"at of _PyFunc_Nin2_Nout1","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"identity":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.identity","name":"identity","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"identity of _PyFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.identity","name":"identity","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"identity of _PyFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"nargs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.nargs","name":"nargs","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nargs of _PyFunc_Nin2_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.nargs","name":"nargs","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nargs of _PyFunc_Nin2_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"nin":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.nin","name":"nin","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nin of _PyFunc_Nin2_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.nin","name":"nin","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nin of _PyFunc_Nin2_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"nout":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.nout","name":"nout","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nout of _PyFunc_Nin2_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.nout","name":"nout","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nout of _PyFunc_Nin2_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"ntypes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.ntypes","name":"ntypes","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ntypes of _PyFunc_Nin2_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.ntypes","name":"ntypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ntypes of _PyFunc_Nin2_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"outer":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.outer","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5,4],"arg_names":[null,null,null,"out","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.outer","name":"outer","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,5,4],"arg_names":[null,null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _PyFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.outer","name":"outer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,5,4],"arg_names":[null,null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _PyFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5,4],"arg_names":[null,null,null,"out","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.outer","name":"outer","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,5,4],"arg_names":[null,null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _PyFunc_Nin2_Nout1","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.outer","name":"outer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,5,4],"arg_names":[null,null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _PyFunc_Nin2_Nout1","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,3,4],"arg_names":[null,null,null,"out","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.outer","name":"outer","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,3,4],"arg_names":[null,null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.outer#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _PyFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.outer#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.outer#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.outer","name":"outer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,3,4],"arg_names":[null,null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.outer#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _PyFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.outer#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.outer#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5,4],"arg_names":[null,null,null,"out","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.outer","name":"outer","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,5,4],"arg_names":[null,null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},"numpy._typing._ufunc._SupportsArrayUFunc",{".class":"UnionType","items":["numpy._typing._ufunc._SupportsArrayUFunc",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _PyFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.outer","name":"outer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,5,4],"arg_names":[null,null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},"numpy._typing._ufunc._SupportsArrayUFunc",{".class":"UnionType","items":["numpy._typing._ufunc._SupportsArrayUFunc",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _PyFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5,4],"arg_names":[null,null,null,"out","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.outer","name":"outer","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,5,4],"arg_names":[null,null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["numpy._typing._ufunc._SupportsArrayUFunc",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _PyFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.outer","name":"outer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,5,4],"arg_names":[null,null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["numpy._typing._ufunc._SupportsArrayUFunc",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _PyFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,5,4],"arg_names":[null,null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _PyFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,5,4],"arg_names":[null,null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _PyFunc_Nin2_Nout1","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,3,4],"arg_names":[null,null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.outer#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _PyFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.outer#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.outer#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,5,4],"arg_names":[null,null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},"numpy._typing._ufunc._SupportsArrayUFunc",{".class":"UnionType","items":["numpy._typing._ufunc._SupportsArrayUFunc",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _PyFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,5,4],"arg_names":[null,null,null,"out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["numpy._typing._ufunc._SupportsArrayUFunc",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _PyFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"reduce":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduce","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0,1,1,1],"arg_names":[null,null,null,null,null,"keepdims","initial","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduce","name":"reduce","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,1,1,1],"arg_names":[null,null,null,null,null,"keepdims","initial","where"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduce#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduce of _PyFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduce#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduce#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduce","name":"reduce","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,1,1,1],"arg_names":[null,null,null,null,null,"keepdims","initial","where"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduce#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduce of _PyFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduce#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduce#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,3,5,5,5],"arg_names":[null,"array","axis","dtype","out","keepdims","initial","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduce","name":"reduce","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5,5,5],"arg_names":[null,"array","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduce#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"TupleType","implicit":false,"items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduce#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduce of _PyFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduce#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduce#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduce","name":"reduce","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5,5,5],"arg_names":[null,"array","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduce#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"TupleType","implicit":false,"items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduce#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduce of _PyFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduce#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduce#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,3,5,5],"arg_names":[null,"array","axis","dtype","out","keepdims","initial","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduce","name":"reduce","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,3,5,5],"arg_names":[null,"array","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduce of _PyFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduce","name":"reduce","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,3,5,5],"arg_names":[null,"array","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduce of _PyFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,1],"arg_names":[null,"array","axis","dtype","out","keepdims","initial","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduce","name":"reduce","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1],"arg_names":[null,"array","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduce of _PyFunc_Nin2_Nout1","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduce","name":"reduce","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1],"arg_names":[null,"array","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduce of _PyFunc_Nin2_Nout1","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,0,0,1,1,1],"arg_names":[null,null,null,null,null,"keepdims","initial","where"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduce#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduce of _PyFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduce#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduce#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,3,5,5,5],"arg_names":[null,"array","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduce#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"TupleType","implicit":false,"items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduce#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduce of _PyFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduce#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduce#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,3,5,5],"arg_names":[null,"array","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduce of _PyFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1],"arg_names":[null,"array","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduce of _PyFunc_Nin2_Nout1","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"reduceat":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduceat","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0,0],"arg_names":[null,null,null,null,null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduceat","name":"reduceat","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0],"arg_names":[null,null,null,null,null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduceat#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduceat of _PyFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduceat#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduceat#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduceat","name":"reduceat","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0],"arg_names":[null,null,null,null,null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduceat#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduceat of _PyFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduceat#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduceat#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,3],"arg_names":[null,"array","indices","axis","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduceat","name":"reduceat","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,3],"arg_names":[null,"array","indices","axis","dtype","out"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduceat#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"TupleType","implicit":false,"items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduceat#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduceat of _PyFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduceat#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduceat#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduceat","name":"reduceat","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,3],"arg_names":[null,"array","indices","axis","dtype","out"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduceat#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"TupleType","implicit":false,"items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduceat#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduceat of _PyFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduceat#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduceat#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1],"arg_names":[null,"array","indices","axis","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduceat","name":"reduceat","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":[null,"array","indices","axis","dtype","out"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduceat of _PyFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduceat","name":"reduceat","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":[null,"array","indices","axis","dtype","out"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduceat of _PyFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1],"arg_names":[null,"array","indices","axis","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduceat","name":"reduceat","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":[null,"array","indices","axis","dtype","out"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},"numpy._typing._ufunc._SupportsArrayUFunc",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduceat of _PyFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduceat","name":"reduceat","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":[null,"array","indices","axis","dtype","out"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},"numpy._typing._ufunc._SupportsArrayUFunc",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduceat of _PyFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,0,0,0],"arg_names":[null,null,null,null,null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduceat#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduceat of _PyFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduceat#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduceat#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,3],"arg_names":[null,"array","indices","axis","dtype","out"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduceat#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"TupleType","implicit":false,"items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduceat#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduceat of _PyFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduceat#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.reduceat#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":[null,"array","indices","axis","dtype","out"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduceat of _PyFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":[null,"array","indices","axis","dtype","out"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},"numpy._typing._ufunc._SupportsArrayUFunc",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduceat of _PyFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"signature":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.signature","name":"signature","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"signature of _PyFunc_Nin2_Nout1","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.signature","name":"signature","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"signature of _PyFunc_Nin2_Nout1","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._PyFunc_Nin2_Nout1.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin2_Nout1"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_ReturnType_co","_IDType"],"typeddict_type":null}},"_PyFunc_Nin3P_Nout1":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy.ufunc"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","name":"_PyFunc_Nin3P_Nout1","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.int","values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._typing._ufunc","mro":["numpy._typing._ufunc._PyFunc_Nin3P_Nout1","numpy.ufunc","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.__call__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,2,5,4],"arg_names":[null,null,null,null,"xs","out","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,2,5,4],"arg_names":[null,null,null,null,"xs","out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin3P_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,2,5,4],"arg_names":[null,null,null,null,"xs","out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin3P_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,2,5,4],"arg_names":[null,null,null,null,"xs","out","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,2,5,4],"arg_names":[null,null,null,null,"xs","out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin3P_Nout1","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,2,5,4],"arg_names":[null,null,null,null,"xs","out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin3P_Nout1","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,2,3,4],"arg_names":[null,null,null,null,"xs","out","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,2,3,4],"arg_names":[null,null,null,null,"xs","out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"TupleType","implicit":false,"items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin3P_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,2,3,4],"arg_names":[null,null,null,null,"xs","out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"TupleType","implicit":false,"items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin3P_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,2,5,4],"arg_names":[null,null,null,null,"xs","out","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,2,5,4],"arg_names":[null,null,null,null,"xs","out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1"},{".class":"UnionType","items":["numpy._typing._ufunc._SupportsArrayUFunc",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._ufunc._SupportsArrayUFunc",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._ufunc._SupportsArrayUFunc",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._ufunc._SupportsArrayUFunc",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin3P_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,2,5,4],"arg_names":[null,null,null,null,"xs","out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1"},{".class":"UnionType","items":["numpy._typing._ufunc._SupportsArrayUFunc",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._ufunc._SupportsArrayUFunc",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._ufunc._SupportsArrayUFunc",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._ufunc._SupportsArrayUFunc",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin3P_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,0,2,5,4],"arg_names":[null,null,null,null,"xs","out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin3P_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,2,5,4],"arg_names":[null,null,null,null,"xs","out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin3P_Nout1","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,2,3,4],"arg_names":[null,null,null,null,"xs","out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"TupleType","implicit":false,"items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin3P_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.__call__#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,0,2,5,4],"arg_names":[null,null,null,null,"xs","out","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1"},{".class":"UnionType","items":["numpy._typing._ufunc._SupportsArrayUFunc",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._ufunc._SupportsArrayUFunc",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._ufunc._SupportsArrayUFunc",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._ufunc._SupportsArrayUFunc",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PyFunc_Nin3P_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"accumulate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.accumulate","name":"accumulate","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"accumulate of _PyFunc_Nin3P_Nout1","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"at":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.at","name":"at","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"at of _PyFunc_Nin3P_Nout1","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"identity":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.identity","name":"identity","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"identity of _PyFunc_Nin3P_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.identity","name":"identity","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"identity of _PyFunc_Nin3P_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"nin":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.nin","name":"nin","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nin of _PyFunc_Nin3P_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.int","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.nin","name":"nin","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nin of _PyFunc_Nin3P_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.int","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"nout":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.nout","name":"nout","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nout of _PyFunc_Nin3P_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.nout","name":"nout","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nout of _PyFunc_Nin3P_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"ntypes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.ntypes","name":"ntypes","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ntypes of _PyFunc_Nin3P_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.ntypes","name":"ntypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ntypes of _PyFunc_Nin3P_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"outer":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.outer","name":"outer","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _PyFunc_Nin3P_Nout1","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"reduce":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.reduce","name":"reduce","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduce of _PyFunc_Nin3P_Nout1","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"reduceat":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.reduceat","name":"reduceat","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduceat of _PyFunc_Nin3P_Nout1","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"signature":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.signature","name":"signature","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"signature of _PyFunc_Nin3P_Nout1","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.signature","name":"signature","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"signature of _PyFunc_Nin3P_Nout1","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","id":1,"name":"_ReturnType_co","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":2,"name":"_IDType","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.object","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NIn","id":3,"name":"_NIn","namespace":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._PyFunc_Nin3P_Nout1"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_ReturnType_co","_IDType","_NIn"],"typeddict_type":null}},"_ReturnType_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._ReturnType_co","name":"_ReturnType_co","upper_bound":"builtins.object","values":[],"variance":1}},"_ScalarLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._ScalarLike_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ShapeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._shape._ShapeLike","kind":"Gdef","module_hidden":true,"module_public":false},"_Signature":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._Signature","name":"_Signature","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}},"_SupportsArrayUFunc":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._typing._ufunc._SupportsArrayUFunc","name":"_SupportsArrayUFunc","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy._typing._ufunc._SupportsArrayUFunc","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy._typing._ufunc","mro":["numpy._typing._ufunc._SupportsArrayUFunc","builtins.object"],"names":{".class":"SymbolTable","__array_ufunc__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,2,4],"arg_names":["self","ufunc","method","inputs","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._SupportsArrayUFunc.__array_ufunc__","name":"__array_ufunc__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,2,4],"arg_names":["self","ufunc","method","inputs","kwargs"],"arg_types":["numpy._typing._ufunc._SupportsArrayUFunc","numpy.ufunc",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"__call__"},{".class":"LiteralType","fallback":"builtins.str","value":"reduce"},{".class":"LiteralType","fallback":"builtins.str","value":"reduceat"},{".class":"LiteralType","fallback":"builtins.str","value":"accumulate"},{".class":"LiteralType","fallback":"builtins.str","value":"outer"},{".class":"LiteralType","fallback":"builtins.str","value":"at"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__array_ufunc__ of _SupportsArrayUFunc","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._SupportsArrayUFunc.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy._typing._ufunc._SupportsArrayUFunc","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_T":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._T","name":"_T","upper_bound":"builtins.object","values":[],"variance":0}},"_UFunc3Kwargs":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._typing._ufunc._UFunc3Kwargs","name":"_UFunc3Kwargs","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy._typing._ufunc._UFunc3Kwargs","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._typing._ufunc","mro":["numpy._typing._ufunc._UFunc3Kwargs","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["where",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],["casting",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],["order",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],["subok","builtins.bool"],["signature",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},"builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}]],"readonly_keys":[],"required_keys":[]}}},"_UFunc_Nin1_Nout1":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy.ufunc"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout1","name":"_UFunc_Nin1_Nout1","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout1","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._typing._ufunc","mro":["numpy._typing._ufunc._UFunc_Nin1_Nout1","numpy.ufunc","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout1.__call__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,5,5,5,5,5,5],"arg_names":["self",null,"out","where","casting","order","dtype","subok","signature"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout1.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,5,5,5,5,5,5],"arg_names":["self",null,"out","where","casting","order","dtype","subok","signature"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin1_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout1.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,5,5,5,5,5,5],"arg_names":["self",null,"out","where","casting","order","dtype","subok","signature"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin1_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,5,5,5,5,5,5],"arg_names":["self",null,"out","where","casting","order","dtype","subok","signature"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout1.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,5,5,5,5,5,5],"arg_names":["self",null,"out","where","casting","order","dtype","subok","signature"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin1_Nout1","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout1.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,5,5,5,5,5,5],"arg_names":["self",null,"out","where","casting","order","dtype","subok","signature"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin1_Nout1","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,5,5,5,5,5,5],"arg_names":["self",null,"out","where","casting","order","dtype","subok","signature"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout1.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,5,5,5,5,5,5],"arg_names":["self",null,"out","where","casting","order","dtype","subok","signature"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout1"},"numpy._typing._ufunc._SupportsArrayUFunc",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin1_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout1.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,5,5,5,5,5,5],"arg_names":["self",null,"out","where","casting","order","dtype","subok","signature"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout1"},"numpy._typing._ufunc._SupportsArrayUFunc",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin1_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,5,5,5,5,5,5],"arg_names":["self",null,"out","where","casting","order","dtype","subok","signature"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin1_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,5,5,5,5,5,5],"arg_names":["self",null,"out","where","casting","order","dtype","subok","signature"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin1_Nout1","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,5,5,5,5,5,5],"arg_names":["self",null,"out","where","casting","order","dtype","subok","signature"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout1"},"numpy._typing._ufunc._SupportsArrayUFunc",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin1_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"__name__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout1.__name__","name":"__name__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__name__ of _UFunc_Nin1_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout1.__name__","name":"__name__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__name__ of _UFunc_Nin1_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__qualname__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout1.__qualname__","name":"__qualname__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__qualname__ of _UFunc_Nin1_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout1.__qualname__","name":"__qualname__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__qualname__ of _UFunc_Nin1_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"accumulate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout1.accumulate","name":"accumulate","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout1"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"accumulate of _UFunc_Nin1_Nout1","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"at":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":[null,null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout1.at","name":"at","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout1"},"numpy._typing._ufunc._SupportsArrayUFunc",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"at of _UFunc_Nin1_Nout1","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"identity":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout1.identity","name":"identity","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"identity of _UFunc_Nin1_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout1.identity","name":"identity","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"identity of _UFunc_Nin1_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"nargs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout1.nargs","name":"nargs","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nargs of _UFunc_Nin1_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout1.nargs","name":"nargs","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nargs of _UFunc_Nin1_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"nin":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout1.nin","name":"nin","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nin of _UFunc_Nin1_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout1.nin","name":"nin","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nin of _UFunc_Nin1_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"nout":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout1.nout","name":"nout","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nout of _UFunc_Nin1_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout1.nout","name":"nout","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nout of _UFunc_Nin1_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"ntypes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout1.ntypes","name":"ntypes","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ntypes of _UFunc_Nin1_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.int","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout1.ntypes","name":"ntypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ntypes of _UFunc_Nin1_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.int","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"outer":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout1.outer","name":"outer","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout1"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _UFunc_Nin1_Nout1","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"reduce":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout1.reduce","name":"reduce","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout1"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduce of _UFunc_Nin1_Nout1","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"reduceat":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout1.reduceat","name":"reduceat","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout1"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduceat of _UFunc_Nin1_Nout1","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"signature":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout1.signature","name":"signature","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"signature of _UFunc_Nin1_Nout1","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout1.signature","name":"signature","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"signature of _UFunc_Nin1_Nout1","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout1.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout1"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_NameType","_NTypes","_IDType"],"typeddict_type":null}},"_UFunc_Nin1_Nout2":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy.ufunc"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout2","name":"_UFunc_Nin1_Nout2","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.object","values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout2","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._typing._ufunc","mro":["numpy._typing._ufunc._UFunc_Nin1_Nout2","numpy.ufunc","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout2.__call__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,5,5,5,5,5,5],"arg_names":["self",null,null,null,"where","casting","order","dtype","subok","signature"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout2.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,5,5,5,5,5,5],"arg_names":["self",null,null,null,"where","casting","order","dtype","subok","signature"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout2"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin1_Nout2","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout2.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,5,5,5,5,5,5],"arg_names":["self",null,null,null,"where","casting","order","dtype","subok","signature"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout2"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin1_Nout2","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,5,5,5,5,5,5,5],"arg_names":["self",null,null,null,"out","where","casting","order","dtype","subok","signature"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout2.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,5,5,5,5,5,5,5],"arg_names":["self",null,null,null,"out","where","casting","order","dtype","subok","signature"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout2"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin1_Nout2","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout2.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,5,5,5,5,5,5,5],"arg_names":["self",null,null,null,"out","where","casting","order","dtype","subok","signature"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout2"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin1_Nout2","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,5,5,5,5,5,5,5],"arg_names":["self",null,null,null,"out","where","casting","order","dtype","subok","signature"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout2.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,5,5,5,5,5,5,5],"arg_names":["self",null,null,null,"out","where","casting","order","dtype","subok","signature"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout2"},"numpy._typing._ufunc._SupportsArrayUFunc",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin1_Nout2","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout2.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,5,5,5,5,5,5,5],"arg_names":["self",null,null,null,"out","where","casting","order","dtype","subok","signature"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout2"},"numpy._typing._ufunc._SupportsArrayUFunc",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin1_Nout2","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1,5,5,5,5,5,5],"arg_names":["self",null,null,null,"where","casting","order","dtype","subok","signature"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout2"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin1_Nout2","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,5,5,5,5,5,5,5],"arg_names":["self",null,null,null,"out","where","casting","order","dtype","subok","signature"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout2"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin1_Nout2","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,5,5,5,5,5,5,5],"arg_names":["self",null,null,null,"out","where","casting","order","dtype","subok","signature"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout2"},"numpy._typing._ufunc._SupportsArrayUFunc",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin1_Nout2","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"__name__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout2.__name__","name":"__name__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout2"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__name__ of _UFunc_Nin1_Nout2","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout2.__name__","name":"__name__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout2"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__name__ of _UFunc_Nin1_Nout2","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__qualname__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout2.__qualname__","name":"__qualname__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout2"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__qualname__ of _UFunc_Nin1_Nout2","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout2.__qualname__","name":"__qualname__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout2"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__qualname__ of _UFunc_Nin1_Nout2","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"accumulate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout2.accumulate","name":"accumulate","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout2"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"accumulate of _UFunc_Nin1_Nout2","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"at":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout2.at","name":"at","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout2"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"at of _UFunc_Nin1_Nout2","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"identity":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout2.identity","name":"identity","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout2"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"identity of _UFunc_Nin1_Nout2","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout2.identity","name":"identity","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout2"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"identity of _UFunc_Nin1_Nout2","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"nargs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout2.nargs","name":"nargs","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout2"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nargs of _UFunc_Nin1_Nout2","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout2.nargs","name":"nargs","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout2"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nargs of _UFunc_Nin1_Nout2","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"nin":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout2.nin","name":"nin","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout2"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nin of _UFunc_Nin1_Nout2","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout2.nin","name":"nin","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout2"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nin of _UFunc_Nin1_Nout2","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"nout":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout2.nout","name":"nout","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout2"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nout of _UFunc_Nin1_Nout2","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout2.nout","name":"nout","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout2"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nout of _UFunc_Nin1_Nout2","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"ntypes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout2.ntypes","name":"ntypes","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout2"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ntypes of _UFunc_Nin1_Nout2","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.int","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout2.ntypes","name":"ntypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout2"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ntypes of _UFunc_Nin1_Nout2","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.int","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"outer":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout2.outer","name":"outer","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout2"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _UFunc_Nin1_Nout2","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"reduce":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout2.reduce","name":"reduce","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout2"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduce of _UFunc_Nin1_Nout2","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"reduceat":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout2.reduceat","name":"reduceat","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout2"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduceat of _UFunc_Nin1_Nout2","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"signature":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout2.signature","name":"signature","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout2"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"signature of _UFunc_Nin1_Nout2","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout2.signature","name":"signature","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout2"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"signature of _UFunc_Nin1_Nout2","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._UFunc_Nin1_Nout2.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin1_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin1_Nout2"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_NameType","_NTypes","_IDType"],"typeddict_type":null}},"_UFunc_Nin2_Nout1":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy.ufunc"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1","name":"_UFunc_Nin2_Nout1","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._typing._ufunc","mro":["numpy._typing._ufunc._UFunc_Nin2_Nout1","numpy.ufunc","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.__call__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin2_Nout1","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin2_Nout1","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,1,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin2_Nout1","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"__name__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.__name__","name":"__name__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__name__ of _UFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.__name__","name":"__name__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__name__ of _UFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__qualname__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.__qualname__","name":"__qualname__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__qualname__ of _UFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.__qualname__","name":"__qualname__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__qualname__ of _UFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"accumulate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["self","array","axis","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.accumulate","name":"accumulate","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","array","axis","dtype","out"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"accumulate of _UFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"at":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":[null,null,null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.at","name":"at","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,null,null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"at of _UFunc_Nin2_Nout1","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"identity":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.identity","name":"identity","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"identity of _UFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.identity","name":"identity","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"identity of _UFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"nargs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.nargs","name":"nargs","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nargs of _UFunc_Nin2_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.nargs","name":"nargs","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nargs of _UFunc_Nin2_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"nin":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.nin","name":"nin","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nin of _UFunc_Nin2_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.nin","name":"nin","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nin of _UFunc_Nin2_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"nout":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.nout","name":"nout","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nout of _UFunc_Nin2_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.nout","name":"nout","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nout of _UFunc_Nin2_Nout1","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"ntypes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.ntypes","name":"ntypes","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ntypes of _UFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.ntypes","name":"ntypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ntypes of _UFunc_Nin2_Nout1","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"outer":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.outer","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.outer","name":"outer","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,5,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _UFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.outer","name":"outer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,5,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _UFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.outer","name":"outer","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,5,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _UFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.outer","name":"outer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,5,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _UFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.outer","name":"outer","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,5,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _UFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.outer","name":"outer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,5,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _UFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,3,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.outer","name":"outer","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,3,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _UFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.outer","name":"outer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,3,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _UFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.outer","name":"outer","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,5,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _UFunc_Nin2_Nout1","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.outer","name":"outer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,5,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _UFunc_Nin2_Nout1","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,5,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _UFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,5,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _UFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,5,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _UFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,3,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _UFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,5,5,4],"arg_names":[null,null,null,"out","dtype","kwds"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _UFunc_Nin2_Nout1","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"reduce":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,1],"arg_names":["self","array","axis","dtype","out","keepdims","initial","where"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.reduce","name":"reduce","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1],"arg_names":["self","array","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduce of _UFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"reduceat":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1],"arg_names":["self","array","indices","axis","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.reduceat","name":"reduceat","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["self","array","indices","axis","dtype","out"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduceat of _UFunc_Nin2_Nout1","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"signature":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.signature","name":"signature","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"signature of _UFunc_Nin2_Nout1","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.signature","name":"signature","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"signature of _UFunc_Nin2_Nout1","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout1.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout1","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout1"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_NameType","_NTypes","_IDType"],"typeddict_type":null}},"_UFunc_Nin2_Nout2":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy.ufunc"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout2","name":"_UFunc_Nin2_Nout2","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.object","values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout2","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy._typing._ufunc","mro":["numpy._typing._ufunc._UFunc_Nin2_Nout2","numpy.ufunc","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout2.__call__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,5,5,5,5,5,5],"arg_names":["self",null,null,null,null,"where","casting","order","dtype","subok","signature"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout2.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,5,5,5,5,5,5],"arg_names":["self",null,null,null,null,"where","casting","order","dtype","subok","signature"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout2"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin2_Nout2","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout2.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,5,5,5,5,5,5],"arg_names":["self",null,null,null,null,"where","casting","order","dtype","subok","signature"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout2"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin2_Nout2","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,5,5,5,5,5,5,5],"arg_names":["self",null,null,null,null,"out","where","casting","order","dtype","subok","signature"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout2.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,5,5,5,5,5,5,5],"arg_names":["self",null,null,null,null,"out","where","casting","order","dtype","subok","signature"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout2"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin2_Nout2","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout2.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,5,5,5,5,5,5,5],"arg_names":["self",null,null,null,null,"out","where","casting","order","dtype","subok","signature"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout2"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin2_Nout2","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,1,1,5,5,5,5,5,5],"arg_names":["self",null,null,null,null,"where","casting","order","dtype","subok","signature"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout2"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin2_Nout2","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,5,5,5,5,5,5,5],"arg_names":["self",null,null,null,null,"out","where","casting","order","dtype","subok","signature"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout2"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _UFunc_Nin2_Nout2","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"__name__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout2.__name__","name":"__name__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout2"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__name__ of _UFunc_Nin2_Nout2","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout2.__name__","name":"__name__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout2"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__name__ of _UFunc_Nin2_Nout2","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__qualname__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout2.__qualname__","name":"__qualname__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout2"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__qualname__ of _UFunc_Nin2_Nout2","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout2.__qualname__","name":"__qualname__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout2"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__qualname__ of _UFunc_Nin2_Nout2","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"accumulate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout2.accumulate","name":"accumulate","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout2"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"accumulate of _UFunc_Nin2_Nout2","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"at":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout2.at","name":"at","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout2"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"at of _UFunc_Nin2_Nout2","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"identity":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout2.identity","name":"identity","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout2"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"identity of _UFunc_Nin2_Nout2","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout2.identity","name":"identity","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout2"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"identity of _UFunc_Nin2_Nout2","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"nargs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout2.nargs","name":"nargs","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout2"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nargs of _UFunc_Nin2_Nout2","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":4},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout2.nargs","name":"nargs","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout2"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nargs of _UFunc_Nin2_Nout2","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":4},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"nin":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout2.nin","name":"nin","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout2"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nin of _UFunc_Nin2_Nout2","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout2.nin","name":"nin","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout2"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nin of _UFunc_Nin2_Nout2","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"nout":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout2.nout","name":"nout","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout2"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nout of _UFunc_Nin2_Nout2","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout2.nout","name":"nout","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout2"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nout of _UFunc_Nin2_Nout2","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"ntypes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout2.ntypes","name":"ntypes","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout2"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ntypes of _UFunc_Nin2_Nout2","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.int","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout2.ntypes","name":"ntypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout2"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ntypes of _UFunc_Nin2_Nout2","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.int","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"outer":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout2.outer","name":"outer","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout2"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer of _UFunc_Nin2_Nout2","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"reduce":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout2.reduce","name":"reduce","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout2"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduce of _UFunc_Nin2_Nout2","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"reduceat":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout2.reduceat","name":"reduceat","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout2"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reduceat of _UFunc_Nin2_Nout2","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"signature":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout2.signature","name":"signature","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout2"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"signature of _UFunc_Nin2_Nout2","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout2.signature","name":"signature","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout2"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"signature of _UFunc_Nin2_Nout2","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._UFunc_Nin2_Nout2.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NameType","id":1,"name":"_NameType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._ufunc.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._NTypes","id":2,"name":"_NTypes","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._typing._ufunc._IDType","id":3,"name":"_IDType","namespace":"numpy._typing._ufunc._UFunc_Nin2_Nout2","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._UFunc_Nin2_Nout2"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_NameType","_NTypes","_IDType"],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._ufunc.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._ufunc.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._ufunc.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._ufunc.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._ufunc.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy._typing._ufunc.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false},"type_check_only":{".class":"SymbolTableNode","cross_ref":"typing.type_check_only","kind":"Gdef","module_hidden":true,"module_public":false},"ufunc":{".class":"SymbolTableNode","cross_ref":"numpy.ufunc","kind":"Gdef","module_hidden":true,"module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_typing/_ufunc.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_ufunc.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_ufunc.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..1c1553abbf3fcb1279ff5612e50e1a5f33cd6e29 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/_typing/_ufunc.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[29,30,31,32,27,9,25,1,1,1],"dep_prios":[5,5,5,5,5,5,5,5,30,30],"dependencies":["numpy._typing._array_like","numpy._typing._dtype_like","numpy._typing._scalars","numpy._typing._shape","numpy.typing","typing","numpy","builtins","_frozen_importlib","abc"],"hash":"ad8b92e33af98f7e414e7417938039befe9d35f3","id":"numpy._typing._ufunc","ignore_all":true,"interface_hash":"ba6151fdf7a682bd6f5cfbf1e937c345ab48c82d","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/_typing/_ufunc.pyi","plugin_data":null,"size":26575,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/char/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/char/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..38a8518ed4ea9348a508214a4f56cab2ca29a804 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/char/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.char","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.char.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.char.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.char.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.char.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.char.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.char.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.char.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.char.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"add":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.add","kind":"Gdef"},"array":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.array","kind":"Gdef"},"asarray":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.asarray","kind":"Gdef"},"capitalize":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.capitalize","kind":"Gdef"},"center":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.center","kind":"Gdef"},"chararray":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.chararray","kind":"Gdef"},"compare_chararrays":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.compare_chararrays","kind":"Gdef"},"count":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.count","kind":"Gdef"},"decode":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.decode","kind":"Gdef"},"encode":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.encode","kind":"Gdef"},"endswith":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.endswith","kind":"Gdef"},"equal":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.equal","kind":"Gdef"},"expandtabs":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.expandtabs","kind":"Gdef"},"find":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.find","kind":"Gdef"},"greater":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.greater","kind":"Gdef"},"greater_equal":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.greater_equal","kind":"Gdef"},"index":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.index","kind":"Gdef"},"isalnum":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.isalnum","kind":"Gdef"},"isalpha":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.isalpha","kind":"Gdef"},"isdecimal":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.isdecimal","kind":"Gdef"},"isdigit":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.isdigit","kind":"Gdef"},"islower":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.islower","kind":"Gdef"},"isnumeric":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.isnumeric","kind":"Gdef"},"isspace":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.isspace","kind":"Gdef"},"istitle":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.istitle","kind":"Gdef"},"isupper":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.isupper","kind":"Gdef"},"join":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.join","kind":"Gdef"},"less":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.less","kind":"Gdef"},"less_equal":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.less_equal","kind":"Gdef"},"ljust":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.ljust","kind":"Gdef"},"lower":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.lower","kind":"Gdef"},"lstrip":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.lstrip","kind":"Gdef"},"mod":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.mod","kind":"Gdef"},"multiply":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.multiply","kind":"Gdef"},"not_equal":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.not_equal","kind":"Gdef"},"partition":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.partition","kind":"Gdef"},"replace":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.replace","kind":"Gdef"},"rfind":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.rfind","kind":"Gdef"},"rindex":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.rindex","kind":"Gdef"},"rjust":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.rjust","kind":"Gdef"},"rpartition":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.rpartition","kind":"Gdef"},"rsplit":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.rsplit","kind":"Gdef"},"rstrip":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.rstrip","kind":"Gdef"},"split":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.split","kind":"Gdef"},"splitlines":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.splitlines","kind":"Gdef"},"startswith":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.startswith","kind":"Gdef"},"str_len":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.str_len","kind":"Gdef"},"strip":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.strip","kind":"Gdef"},"swapcase":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.swapcase","kind":"Gdef"},"title":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.title","kind":"Gdef"},"translate":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.translate","kind":"Gdef"},"upper":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.upper","kind":"Gdef"},"zfill":{".class":"SymbolTableNode","cross_ref":"numpy._core.defchararray.zfill","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/char/__init__.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/char/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/char/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..7e6a759218c221aff5adf2121c729ec8c4c2011b --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/char/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,1,1,1,1],"dep_prios":[5,5,30,30,30],"dependencies":["numpy._core.defchararray","builtins","_frozen_importlib","abc","typing"],"hash":"a390ba50016e470705546a9330cb57b45243bd06","id":"numpy.char","ignore_all":true,"interface_hash":"b57cb49386c2bc14e4ac1b56ba40ff7c46a617ab","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/char/__init__.pyi","plugin_data":null,"size":1540,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/core/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/core/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..e295b08c9f67e82a2020f828dab4ccf35b5e8b25 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/core/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.core","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.core.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.core.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.core.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.core.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.core.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.core.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.core.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/core/__init__.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/core/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/core/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..2edebe3384fb24657e81b273deea55ada082f85c --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/core/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106714,"dep_lines":[1,1,1,1],"dep_prios":[5,30,30,30],"dependencies":["builtins","_frozen_importlib","abc","typing"],"hash":"da39a3ee5e6b4b0d3255bfef95601890afd80709","id":"numpy.core","ignore_all":true,"interface_hash":"ac936596ac99b4c613ec14859d0994e46b2ee93d","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/core/__init__.pyi","plugin_data":null,"size":0,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/ctypeslib/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/ctypeslib/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..4aadf0e9f85be766eafa7bab38e7ee5eb29874f0 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/ctypeslib/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.ctypeslib","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","__all__":{".class":"SymbolTableNode","cross_ref":"numpy.ctypeslib._ctypeslib.__all__","kind":"Gdef","module_public":false},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ctypeslib.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ctypeslib.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ctypeslib.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ctypeslib.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ctypeslib.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ctypeslib.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ctypeslib.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_c_intp":{".class":"SymbolTableNode","cross_ref":"ctypes.c_int64","kind":"Gdef","module_hidden":true,"module_public":false},"_concrete_ndptr":{".class":"SymbolTableNode","cross_ref":"numpy.ctypeslib._ctypeslib._concrete_ndptr","kind":"Gdef","module_public":false},"_ndptr":{".class":"SymbolTableNode","cross_ref":"numpy.ctypeslib._ctypeslib._ndptr","kind":"Gdef","module_public":false},"as_array":{".class":"SymbolTableNode","cross_ref":"numpy.ctypeslib._ctypeslib.as_array","kind":"Gdef"},"as_ctypes":{".class":"SymbolTableNode","cross_ref":"numpy.ctypeslib._ctypeslib.as_ctypes","kind":"Gdef"},"as_ctypes_type":{".class":"SymbolTableNode","cross_ref":"numpy.ctypeslib._ctypeslib.as_ctypes_type","kind":"Gdef"},"c_intp":{".class":"SymbolTableNode","cross_ref":"numpy.ctypeslib._ctypeslib.c_intp","kind":"Gdef"},"ctypes":{".class":"SymbolTableNode","cross_ref":"ctypes","kind":"Gdef","module_hidden":true,"module_public":false},"load_library":{".class":"SymbolTableNode","cross_ref":"numpy.ctypeslib._ctypeslib.load_library","kind":"Gdef"},"ndpointer":{".class":"SymbolTableNode","cross_ref":"numpy.ctypeslib._ctypeslib.ndpointer","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/ctypeslib/__init__.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/ctypeslib/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/ctypeslib/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..ef96fd003daff14a95ca6a3b6fa140c3b0bc5d36 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/ctypeslib/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[4,1,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["numpy.ctypeslib._ctypeslib","ctypes","builtins","_frozen_importlib","abc","typing"],"hash":"89fd399099359612fdff55a6e9b5401382f1a28c","id":"numpy.ctypeslib","ignore_all":true,"interface_hash":"33f139fe7ba8e8b36e3d82c304387cc069deea30","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/ctypeslib/__init__.pyi","plugin_data":null,"size":619,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/ctypeslib/_ctypeslib.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/ctypeslib/_ctypeslib.data.json new file mode 100644 index 0000000000000000000000000000000000000000..62d751843b16a5088a65b46926725d4dfbdb0ab8 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/ctypeslib/_ctypeslib.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.ctypeslib._ctypeslib","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"ClassVar":{".class":"SymbolTableNode","cross_ref":"typing.ClassVar","kind":"Gdef","module_hidden":true,"module_public":false},"DTypeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like.DTypeLike","kind":"Gdef","module_hidden":true,"module_public":false},"Generic":{".class":"SymbolTableNode","cross_ref":"typing.Generic","kind":"Gdef","module_hidden":true,"module_public":false},"Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef","module_hidden":true,"module_public":false},"L":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef","module_hidden":true,"module_public":false},"StrOrBytesPath":{".class":"SymbolTableNode","cross_ref":"_typeshed.StrOrBytesPath","kind":"Gdef","module_hidden":true,"module_public":false},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.ctypeslib._ctypeslib.TypeAlias","source_any":null,"type_of_any":3}}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"_AnyShape":{".class":"SymbolTableNode","cross_ref":"numpy._typing._shape._AnyShape","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"_BoolCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._BoolCodes","kind":"Gdef","module_hidden":true,"module_public":false},"_ByteCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._ByteCodes","kind":"Gdef","module_hidden":true,"module_public":false},"_DTypeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._DTypeLike","kind":"Gdef","module_hidden":true,"module_public":false},"_DTypeOptionalT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._DTypeOptionalT","name":"_DTypeOptionalT","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":0}},"_DTypeT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._DTypeT","name":"_DTypeT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}},"_DoubleCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._DoubleCodes","kind":"Gdef","module_hidden":true,"module_public":false},"_FlagsKind":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.ctypeslib._ctypeslib._FlagsKind","name":"_FlagsKind","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.ctypeslib._ctypeslib.TypeAlias","source_any":null,"type_of_any":3}}},"_IntCCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._IntCCodes","kind":"Gdef","module_hidden":true,"module_public":false},"_LongCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._LongCodes","kind":"Gdef","module_hidden":true,"module_public":false},"_LongDoubleCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._LongDoubleCodes","kind":"Gdef","module_hidden":true,"module_public":false},"_LongLongCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._LongLongCodes","kind":"Gdef","module_hidden":true,"module_public":false},"_ScalarT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._ScalarT","name":"_ScalarT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},"_ShapeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._shape._ShapeLike","kind":"Gdef","module_hidden":true,"module_public":false},"_ShortCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._ShortCodes","kind":"Gdef","module_hidden":true,"module_public":false},"_SingleCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._SingleCodes","kind":"Gdef","module_hidden":true,"module_public":false},"_UByteCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._UByteCodes","kind":"Gdef","module_hidden":true,"module_public":false},"_UIntCCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._UIntCCodes","kind":"Gdef","module_hidden":true,"module_public":false},"_ULongCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._ULongCodes","kind":"Gdef","module_hidden":true,"module_public":false},"_ULongLongCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._ULongLongCodes","kind":"Gdef","module_hidden":true,"module_public":false},"_UShortCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._UShortCodes","kind":"Gdef","module_hidden":true,"module_public":false},"_VoidDTypeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._VoidDTypeLike","kind":"Gdef","module_hidden":true,"module_public":false},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.ctypeslib._ctypeslib.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ctypeslib._ctypeslib.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ctypeslib._ctypeslib.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ctypeslib._ctypeslib.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ctypeslib._ctypeslib.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ctypeslib._ctypeslib.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ctypeslib._ctypeslib.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_c_intp":{".class":"SymbolTableNode","cross_ref":"ctypes.c_int64","kind":"Gdef","module_hidden":true,"module_public":false},"_concrete_ndptr":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._DTypeT","id":1,"name":"_DTypeT","namespace":"numpy.ctypeslib._ctypeslib._concrete_ndptr","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ctypeslib._ctypeslib._ndptr"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.ctypeslib._ctypeslib._concrete_ndptr","name":"_concrete_ndptr","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._DTypeT","id":1,"name":"_DTypeT","namespace":"numpy.ctypeslib._ctypeslib._concrete_ndptr","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.ctypeslib._ctypeslib._concrete_ndptr","has_param_spec_type":false,"metaclass_type":"_ctypes._PyCSimpleType","metadata":{},"module_name":"numpy.ctypeslib._ctypeslib","mro":["numpy.ctypeslib._ctypeslib._concrete_ndptr","numpy.ctypeslib._ctypeslib._ndptr","ctypes.c_void_p","_ctypes._PointerLike","_ctypes._CanCastTo","_ctypes._SimpleCData","_ctypes._CData","builtins.object"],"names":{".class":"SymbolTable","_dtype_":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready"],"fullname":"numpy.ctypeslib._ctypeslib._concrete_ndptr._dtype_","name":"_dtype_","setter_type":null,"type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._DTypeT","id":1,"name":"_DTypeT","namespace":"numpy.ctypeslib._ctypeslib._concrete_ndptr","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}}},"_shape_":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready"],"fullname":"numpy.ctypeslib._ctypeslib._concrete_ndptr._shape_","name":"_shape_","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}}},"contents":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy.ctypeslib._ctypeslib._concrete_ndptr.contents","name":"contents","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._DTypeT","id":1,"name":"_DTypeT","namespace":"numpy.ctypeslib._ctypeslib._concrete_ndptr","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ctypeslib._ctypeslib._concrete_ndptr"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"contents of _concrete_ndptr","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._DTypeT","id":1,"name":"_DTypeT","namespace":"numpy.ctypeslib._ctypeslib._concrete_ndptr","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib._concrete_ndptr.contents","name":"contents","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._DTypeT","id":1,"name":"_DTypeT","namespace":"numpy.ctypeslib._ctypeslib._concrete_ndptr","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ctypeslib._ctypeslib._concrete_ndptr"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"contents of _concrete_ndptr","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._DTypeT","id":1,"name":"_DTypeT","namespace":"numpy.ctypeslib._ctypeslib._concrete_ndptr","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._concrete_ndptr.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._DTypeT","id":1,"name":"_DTypeT","namespace":"numpy.ctypeslib._ctypeslib._concrete_ndptr","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ctypeslib._ctypeslib._concrete_ndptr"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_DTypeT"],"typeddict_type":null}},"_ctypes":{".class":"SymbolTableNode","cross_ref":"numpy._core._internal._ctypes","kind":"Gdef","module_hidden":true,"module_public":false},"_ndptr":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["ctypes.c_void_p"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.ctypeslib._ctypeslib._ndptr","name":"_ndptr","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._DTypeOptionalT","id":1,"name":"_DTypeOptionalT","namespace":"numpy.ctypeslib._ctypeslib._ndptr","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":0}]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.ctypeslib._ctypeslib._ndptr","has_param_spec_type":false,"metaclass_type":"_ctypes._PyCSimpleType","metadata":{},"module_name":"numpy.ctypeslib._ctypeslib","mro":["numpy.ctypeslib._ctypeslib._ndptr","ctypes.c_void_p","_ctypes._PointerLike","_ctypes._CanCastTo","_ctypes._SimpleCData","_ctypes._CData","builtins.object"],"names":{".class":"SymbolTable","_dtype_":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready"],"fullname":"numpy.ctypeslib._ctypeslib._ndptr._dtype_","name":"_dtype_","setter_type":null,"type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._DTypeOptionalT","id":1,"name":"_DTypeOptionalT","namespace":"numpy.ctypeslib._ctypeslib._ndptr","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":0}}},"_flags_":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready"],"fullname":"numpy.ctypeslib._ctypeslib._ndptr._flags_","name":"_flags_","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.ctypeslib._ctypeslib.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_ndim_":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready"],"fullname":"numpy.ctypeslib._ctypeslib._ndptr._ndim_","name":"_ndim_","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_shape_":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready"],"fullname":"numpy.ctypeslib._ctypeslib._ndptr._shape_","name":"_shape_","setter_type":null,"type":{".class":"NoneType"}}},"from_param":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":["is_class"],"fullname":"numpy.ctypeslib._ctypeslib._ndptr.from_param","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib._ndptr.from_param","name":"from_param","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","obj"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"NoneType"}],"extra_attrs":null,"type_ref":"numpy.ctypeslib._ctypeslib._ndptr"}},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"from_param of _ndptr","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy._core._internal._ctypes"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_classmethod","is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib._ndptr.from_param","name":"from_param","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","obj"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"NoneType"}],"extra_attrs":null,"type_ref":"numpy.ctypeslib._ctypeslib._ndptr"}},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"from_param of _ndptr","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy._core._internal._ctypes"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib._ndptr.from_param","name":"from_param","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","obj"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy.ctypeslib._ctypeslib._ndptr.from_param","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ctypeslib._ctypeslib._ndptr"}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy.ctypeslib._ctypeslib._ndptr.from_param","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ndarray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"from_param of _ndptr","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy._core._internal._ctypes"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy.ctypeslib._ctypeslib._ndptr.from_param","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_classmethod","is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib._ndptr.from_param","name":"from_param","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","obj"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy.ctypeslib._ctypeslib._ndptr.from_param","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ctypeslib._ctypeslib._ndptr"}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy.ctypeslib._ctypeslib._ndptr.from_param","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ndarray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"from_param of _ndptr","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy._core._internal._ctypes"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy.ctypeslib._ctypeslib._ndptr.from_param","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","obj"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"NoneType"}],"extra_attrs":null,"type_ref":"numpy.ctypeslib._ctypeslib._ndptr"}},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"from_param of _ndptr","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy._core._internal._ctypes"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","obj"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy.ctypeslib._ctypeslib._ndptr.from_param","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ctypeslib._ctypeslib._ndptr"}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy.ctypeslib._ctypeslib._ndptr.from_param","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ndarray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"from_param of _ndptr","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy._core._internal._ctypes"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy.ctypeslib._ctypeslib._ndptr.from_param","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}]}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._ndptr.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._DTypeOptionalT","id":1,"name":"_DTypeOptionalT","namespace":"numpy.ctypeslib._ctypeslib._ndptr","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ctypeslib._ctypeslib._ndptr"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_DTypeOptionalT"],"typeddict_type":null}},"as_array":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.ctypeslib._ctypeslib.as_array","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["obj","shape"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_array","name":"as_array","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["obj","shape"],"arg_types":["_ctypes._PointerLike",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_array","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_array","name":"as_array","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["obj","shape"],"arg_types":["_ctypes._PointerLike",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_array","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["obj","shape"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_array","name":"as_array","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["obj","shape"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_array","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ctypeslib._ctypeslib.as_array#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_array","name":"as_array","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["obj","shape"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_array","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ctypeslib._ctypeslib.as_array#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["obj","shape"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_array","name":"as_array","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["obj","shape"],"arg_types":["builtins.object",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_array","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_array","name":"as_array","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["obj","shape"],"arg_types":["builtins.object",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_array","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["obj","shape"],"arg_types":["_ctypes._PointerLike",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_array","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["obj","shape"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_array","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ctypeslib._ctypeslib.as_array#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["obj","shape"],"arg_types":["builtins.object",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_array","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"as_ctypes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.byte"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_byte","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.byte"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_byte","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.short"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_short","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.short"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_short","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.intc"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.intc"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.long"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_long","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.long"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_long","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.longlong"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_longlong","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.longlong"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_longlong","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_ubyte","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_ubyte","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_ushort","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_ushort","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_uint","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_uint","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_ulong","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_ulong","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_ulonglong","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_ulonglong","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_double","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_double","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_longdouble","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_longdouble","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":["numpy.void"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":["numpy.void"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_bool"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_bool"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_byte"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_byte"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_short"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_short"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_int"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_int"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_long"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_long"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_longlong"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_longlong"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_ubyte"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_ubyte"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_ushort"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_ushort"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_uint"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_uint"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_ulong"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_ulong"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_ulonglong"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_ulonglong"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_float"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_float"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_double"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_double"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_longdouble"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_longdouble"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes","name":"as_ctypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.byte"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_byte","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.short"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_short","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.intc"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.long"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_long","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.longlong"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_longlong","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_ubyte","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_ushort","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_uint","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_ulong","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_ulonglong","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_double","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":"ctypes.c_longdouble","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":["numpy.void"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_bool"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_byte"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_short"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_int"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_long"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_longlong"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_ubyte"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_ushort"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_uint"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_ulong"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_ulonglong"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_float"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_double"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":["ctypes.c_longdouble"],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"_ctypes.Array"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"as_ctypes_type":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes_type","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes_type","name":"as_ctypes_type","original_first_arg":"dtype","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._BoolCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_bool"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes_type","name":"as_ctypes_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._BoolCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_bool"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes_type","name":"as_ctypes_type","original_first_arg":"dtype","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._ByteCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_byte"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_byte"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes_type","name":"as_ctypes_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._ByteCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_byte"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_byte"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes_type","name":"as_ctypes_type","original_first_arg":"dtype","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._ShortCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_short"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_short"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes_type","name":"as_ctypes_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._ShortCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_short"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_short"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes_type","name":"as_ctypes_type","original_first_arg":"dtype","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._IntCCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_int"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_int"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes_type","name":"as_ctypes_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._IntCCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_int"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_int"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes_type","name":"as_ctypes_type","original_first_arg":"dtype","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._LongCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_long"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_long"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes_type","name":"as_ctypes_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._LongCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_long"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_long"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes_type","name":"as_ctypes_type","original_first_arg":"dtype","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"TypeType","item":"builtins.int"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_int64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes_type","name":"as_ctypes_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"TypeType","item":"builtins.int"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_int64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes_type","name":"as_ctypes_type","original_first_arg":"dtype","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._LongLongCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_longlong"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_longlong"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes_type","name":"as_ctypes_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._LongLongCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_longlong"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_longlong"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes_type","name":"as_ctypes_type","original_first_arg":"dtype","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UByteCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_ubyte"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_ubyte"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes_type","name":"as_ctypes_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UByteCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_ubyte"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_ubyte"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes_type","name":"as_ctypes_type","original_first_arg":"dtype","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UShortCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_ushort"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_ushort"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes_type","name":"as_ctypes_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UShortCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_ushort"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_ushort"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes_type","name":"as_ctypes_type","original_first_arg":"dtype","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UIntCCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_uint"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_uint"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes_type","name":"as_ctypes_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UIntCCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_uint"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_uint"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes_type","name":"as_ctypes_type","original_first_arg":"dtype","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._ULongCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_ulong"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_ulong"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes_type","name":"as_ctypes_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._ULongCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_ulong"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_ulong"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes_type","name":"as_ctypes_type","original_first_arg":"dtype","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._ULongLongCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_ulonglong"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_ulonglong"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes_type","name":"as_ctypes_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._ULongLongCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_ulonglong"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_ulonglong"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes_type","name":"as_ctypes_type","original_first_arg":"dtype","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._SingleCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_float"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_float"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes_type","name":"as_ctypes_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._SingleCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_float"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_float"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes_type","name":"as_ctypes_type","original_first_arg":"dtype","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._DoubleCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"builtins.float"},{".class":"TypeType","item":"ctypes.c_double"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_double"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes_type","name":"as_ctypes_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._DoubleCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"builtins.float"},{".class":"TypeType","item":"ctypes.c_double"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_double"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes_type","name":"as_ctypes_type","original_first_arg":"dtype","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._LongDoubleCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_longdouble"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_longdouble"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes_type","name":"as_ctypes_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._LongDoubleCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_longdouble"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_longdouble"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes_type","name":"as_ctypes_type","original_first_arg":"dtype","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes_type","name":"as_ctypes_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes_type","name":"as_ctypes_type","original_first_arg":"dtype","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.as_ctypes_type","name":"as_ctypes_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._BoolCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_bool"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._ByteCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_byte"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_byte"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._ShortCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_short"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_short"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._IntCCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_int"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_int"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._LongCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_long"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_long"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"TypeType","item":"builtins.int"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_int64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._LongLongCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_longlong"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_longlong"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UByteCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_ubyte"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_ubyte"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UShortCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_ushort"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_ushort"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UIntCCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_uint"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_uint"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._ULongCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_ulong"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_ulong"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._ULongLongCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_ulonglong"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_ulonglong"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._SingleCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_float"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_float"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._DoubleCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"builtins.float"},{".class":"TypeType","item":"ctypes.c_double"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_double"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._LongDoubleCodes"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeType","item":"ctypes.c_longdouble"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":"ctypes.c_longdouble"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["dtype"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_ctypes_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"byte":{".class":"SymbolTableNode","cross_ref":"numpy.byte","kind":"Gdef","module_hidden":true,"module_public":false},"c_intp":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy.ctypeslib._ctypeslib.c_intp","line":104,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":"ctypes.c_int64"}},"ctypes":{".class":"SymbolTableNode","cross_ref":"ctypes","kind":"Gdef","module_hidden":true,"module_public":false},"double":{".class":"SymbolTableNode","cross_ref":"numpy.double","kind":"Gdef","module_hidden":true,"module_public":false},"dtype":{".class":"SymbolTableNode","cross_ref":"numpy.dtype","kind":"Gdef","module_hidden":true,"module_public":false},"flagsobj":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.flagsobj","kind":"Gdef","module_hidden":true,"module_public":false},"generic":{".class":"SymbolTableNode","cross_ref":"numpy.generic","kind":"Gdef","module_hidden":true,"module_public":false},"intc":{".class":"SymbolTableNode","cross_ref":"numpy.intc","kind":"Gdef","module_hidden":true,"module_public":false},"load_library":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["libname","loader_path"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ctypeslib._ctypeslib.load_library","name":"load_library","original_first_arg":"libname","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["libname","loader_path"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.StrOrBytesPath"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.StrOrBytesPath"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"load_library","ret_type":"ctypes.CDLL","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"long":{".class":"SymbolTableNode","cross_ref":"numpy.long","kind":"Gdef","module_hidden":true,"module_public":false},"longdouble":{".class":"SymbolTableNode","cross_ref":"numpy.longdouble","kind":"Gdef","module_hidden":true,"module_public":false},"longlong":{".class":"SymbolTableNode","cross_ref":"numpy.longlong","kind":"Gdef","module_hidden":true,"module_public":false},"ndarray":{".class":"SymbolTableNode","cross_ref":"numpy.ndarray","kind":"Gdef","module_hidden":true,"module_public":false},"ndpointer":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.ctypeslib._ctypeslib.ndpointer","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1,1,1,1],"arg_names":["dtype","ndim","shape","flags"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.ndpointer","name":"ndpointer","original_first_arg":"dtype","type":{".class":"CallableType","arg_kinds":[1,1,1,1],"arg_names":["dtype","ndim","shape","flags"],"arg_types":[{".class":"NoneType"},"builtins.int",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.ctypeslib._ctypeslib.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.ctypeslib._ctypeslib.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.int","numpy._core.multiarray.flagsobj",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ndpointer","ret_type":{".class":"TypeType","item":{".class":"Instance","args":[{".class":"NoneType"}],"extra_attrs":null,"type_ref":"numpy.ctypeslib._ctypeslib._ndptr"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.ndpointer","name":"ndpointer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[1,1,1,1],"arg_names":["dtype","ndim","shape","flags"],"arg_types":[{".class":"NoneType"},"builtins.int",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.ctypeslib._ctypeslib.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.ctypeslib._ctypeslib.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.int","numpy._core.multiarray.flagsobj",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ndpointer","ret_type":{".class":"TypeType","item":{".class":"Instance","args":[{".class":"NoneType"}],"extra_attrs":null,"type_ref":"numpy.ctypeslib._ctypeslib._ndptr"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3,5],"arg_names":["dtype","ndim","shape","flags"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.ndpointer","name":"ndpointer","original_first_arg":"dtype","type":{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["dtype","ndim","shape","flags"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.ctypeslib._ctypeslib.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.ctypeslib._ctypeslib.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.int","numpy._core.multiarray.flagsobj",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ndpointer","ret_type":{".class":"TypeType","item":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ctypeslib._ctypeslib.ndpointer#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ctypeslib._ctypeslib._concrete_ndptr"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ctypeslib._ctypeslib.ndpointer#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.ndpointer","name":"ndpointer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["dtype","ndim","shape","flags"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.ctypeslib._ctypeslib.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.ctypeslib._ctypeslib.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.int","numpy._core.multiarray.flagsobj",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ndpointer","ret_type":{".class":"TypeType","item":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ctypeslib._ctypeslib.ndpointer#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ctypeslib._ctypeslib._concrete_ndptr"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ctypeslib._ctypeslib.ndpointer#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3,5],"arg_names":["dtype","ndim","shape","flags"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.ndpointer","name":"ndpointer","original_first_arg":"dtype","type":{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["dtype","ndim","shape","flags"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.ctypeslib._ctypeslib.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.ctypeslib._ctypeslib.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.int","numpy._core.multiarray.flagsobj",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ndpointer","ret_type":{".class":"TypeType","item":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ctypeslib._ctypeslib._concrete_ndptr"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.ndpointer","name":"ndpointer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["dtype","ndim","shape","flags"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.ctypeslib._ctypeslib.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.ctypeslib._ctypeslib.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.int","numpy._core.multiarray.flagsobj",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ndpointer","ret_type":{".class":"TypeType","item":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ctypeslib._ctypeslib._concrete_ndptr"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["dtype","ndim","shape","flags"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.ndpointer","name":"ndpointer","original_first_arg":"dtype","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["dtype","ndim","shape","flags"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int",{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.ctypeslib._ctypeslib.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.ctypeslib._ctypeslib.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.int","numpy._core.multiarray.flagsobj",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ndpointer","ret_type":{".class":"TypeType","item":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ctypeslib._ctypeslib.ndpointer#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ctypeslib._ctypeslib._ndptr"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ctypeslib._ctypeslib.ndpointer#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.ndpointer","name":"ndpointer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["dtype","ndim","shape","flags"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int",{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.ctypeslib._ctypeslib.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.ctypeslib._ctypeslib.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.int","numpy._core.multiarray.flagsobj",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ndpointer","ret_type":{".class":"TypeType","item":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ctypeslib._ctypeslib.ndpointer#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ctypeslib._ctypeslib._ndptr"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ctypeslib._ctypeslib.ndpointer#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["dtype","ndim","shape","flags"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ctypeslib._ctypeslib.ndpointer","name":"ndpointer","original_first_arg":"dtype","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["dtype","ndim","shape","flags"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int",{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.ctypeslib._ctypeslib.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.ctypeslib._ctypeslib.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.int","numpy._core.multiarray.flagsobj",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ndpointer","ret_type":{".class":"TypeType","item":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ctypeslib._ctypeslib._ndptr"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ctypeslib._ctypeslib.ndpointer","name":"ndpointer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["dtype","ndim","shape","flags"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int",{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.ctypeslib._ctypeslib.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.ctypeslib._ctypeslib.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.int","numpy._core.multiarray.flagsobj",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ndpointer","ret_type":{".class":"TypeType","item":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ctypeslib._ctypeslib._ndptr"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[1,1,1,1],"arg_names":["dtype","ndim","shape","flags"],"arg_types":[{".class":"NoneType"},"builtins.int",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.ctypeslib._ctypeslib.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.ctypeslib._ctypeslib.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.int","numpy._core.multiarray.flagsobj",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ndpointer","ret_type":{".class":"TypeType","item":{".class":"Instance","args":[{".class":"NoneType"}],"extra_attrs":null,"type_ref":"numpy.ctypeslib._ctypeslib._ndptr"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["dtype","ndim","shape","flags"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.ctypeslib._ctypeslib.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.ctypeslib._ctypeslib.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.int","numpy._core.multiarray.flagsobj",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ndpointer","ret_type":{".class":"TypeType","item":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ctypeslib._ctypeslib.ndpointer#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ctypeslib._ctypeslib._concrete_ndptr"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ctypeslib._ctypeslib.ndpointer#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["dtype","ndim","shape","flags"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.ctypeslib._ctypeslib.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.ctypeslib._ctypeslib.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.int","numpy._core.multiarray.flagsobj",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ndpointer","ret_type":{".class":"TypeType","item":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ctypeslib._ctypeslib._concrete_ndptr"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["dtype","ndim","shape","flags"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int",{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.ctypeslib._ctypeslib.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.ctypeslib._ctypeslib.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.int","numpy._core.multiarray.flagsobj",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ndpointer","ret_type":{".class":"TypeType","item":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ctypeslib._ctypeslib.ndpointer#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ctypeslib._ctypeslib._ndptr"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ctypeslib._ctypeslib._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ctypeslib._ctypeslib.ndpointer#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["dtype","ndim","shape","flags"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int",{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.ctypeslib._ctypeslib.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.ctypeslib._ctypeslib.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.int","numpy._core.multiarray.flagsobj",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ndpointer","ret_type":{".class":"TypeType","item":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ctypeslib._ctypeslib._ndptr"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false},"short":{".class":"SymbolTableNode","cross_ref":"numpy.short","kind":"Gdef","module_hidden":true,"module_public":false},"single":{".class":"SymbolTableNode","cross_ref":"numpy.single","kind":"Gdef","module_hidden":true,"module_public":false},"ubyte":{".class":"SymbolTableNode","cross_ref":"numpy.ubyte","kind":"Gdef","module_hidden":true,"module_public":false},"uintc":{".class":"SymbolTableNode","cross_ref":"numpy.uintc","kind":"Gdef","module_hidden":true,"module_public":false},"ulong":{".class":"SymbolTableNode","cross_ref":"numpy.ulong","kind":"Gdef","module_hidden":true,"module_public":false},"ulonglong":{".class":"SymbolTableNode","cross_ref":"numpy.ulonglong","kind":"Gdef","module_hidden":true,"module_public":false},"ushort":{".class":"SymbolTableNode","cross_ref":"numpy.ushort","kind":"Gdef","module_hidden":true,"module_public":false},"void":{".class":"SymbolTableNode","cross_ref":"numpy.void","kind":"Gdef","module_hidden":true,"module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/ctypeslib/_ctypeslib.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/ctypeslib/_ctypeslib.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/ctypeslib/_ctypeslib.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..05009ad62892046ce3d924bf5db718ca85fe28a5 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/ctypeslib/_ctypeslib.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[38,39,4,40,3,6,16,18,1,1,1,1,1,1],"dep_prios":[5,5,5,5,5,5,5,5,5,30,30,30,30,30],"dependencies":["numpy._core._internal","numpy._core.multiarray","collections.abc","numpy._typing","ctypes","typing","_typeshed","numpy","builtins","_ctypes","_frozen_importlib","abc","numpy._core","os"],"hash":"c49249664c0f34056d40ad8ef9efbc7724c48e68","id":"numpy.ctypeslib._ctypeslib","ignore_all":true,"interface_hash":"dd4da12bff0616f83ccbde0d09bbe558b9cac792","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/ctypeslib/_ctypeslib.pyi","plugin_data":null,"size":8084,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/f2py/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/f2py/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..250b93cb021809e805cf13f52c707f8d8d188b18 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/f2py/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.f2py","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.f2py.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.f2py.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.f2py.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.f2py.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.f2py.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.f2py.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.f2py.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.f2py.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"get_include":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.get_include","name":"get_include","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_include","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"main":{".class":"SymbolTableNode","cross_ref":"numpy.f2py.f2py2e.main","kind":"Gdef","module_public":false},"run_main":{".class":"SymbolTableNode","cross_ref":"numpy.f2py.f2py2e.run_main","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/f2py/__init__.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/f2py/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/f2py/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..c7222ea9bdbdbb16159bf541ec74f49b51d7213b --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/f2py/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[1,1,1,1,1],"dep_prios":[5,5,30,30,30],"dependencies":["numpy.f2py.f2py2e","builtins","_frozen_importlib","abc","typing"],"hash":"46c47f937341123e4c43d3230cc2b85def286036","id":"numpy.f2py","ignore_all":true,"interface_hash":"54d322066d009448ef1a39481aff851daec778b9","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/f2py/__init__.pyi","plugin_data":null,"size":132,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/f2py/__version__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/f2py/__version__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..02281ec49054c6d5fd3476054f61dac6058f8ea5 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/f2py/__version__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.f2py.__version__","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.f2py.__version__.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.f2py.__version__.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.f2py.__version__.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.f2py.__version__.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.f2py.__version__.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.f2py.__version__.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"version":{".class":"SymbolTableNode","cross_ref":"numpy.version.version","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/f2py/__version__.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/f2py/__version__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/f2py/__version__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..25d0288ae1bffc06b7126089382163c041341c78 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/f2py/__version__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106714,"dep_lines":[1,1,1,1,1],"dep_prios":[5,5,30,30,30],"dependencies":["numpy.version","builtins","_frozen_importlib","abc","typing"],"hash":"9b77953d2be8ae03117546c1ba683841870f0f2f","id":"numpy.f2py.__version__","ignore_all":true,"interface_hash":"942f0faac3fe148aa94722f93faea827c96c1266","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/f2py/__version__.pyi","plugin_data":null,"size":45,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/f2py/auxfuncs.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/f2py/auxfuncs.data.json new file mode 100644 index 0000000000000000000000000000000000000000..272954896a33943ccce67977ec31b1e8cbd4c615 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/f2py/auxfuncs.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.f2py.auxfuncs","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef","module_hidden":true,"module_public":false},"F2PYError":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.Exception"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.f2py.auxfuncs.F2PYError","name":"F2PYError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.F2PYError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.f2py.auxfuncs","mro":["numpy.f2py.auxfuncs.F2PYError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.f2py.auxfuncs.F2PYError.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.f2py.auxfuncs.F2PYError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"FileDescriptorOrPath":{".class":"SymbolTableNode","cross_ref":"_typeshed.FileDescriptorOrPath","kind":"Gdef","module_hidden":true,"module_public":false},"Final":{".class":"SymbolTableNode","cross_ref":"typing.Final","kind":"Gdef","module_hidden":true,"module_public":false},"L":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"Mapping":{".class":"SymbolTableNode","cross_ref":"typing.Mapping","kind":"Gdef","module_hidden":true,"module_public":false},"Never":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.f2py.auxfuncs.Never","name":"Never","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.Never","source_any":null,"type_of_any":3}}},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.f2py.auxfuncs.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"_Bool":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.f2py.auxfuncs._Bool","name":"_Bool","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}}},"_F2CMap":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.f2py.auxfuncs._F2CMap","name":"_F2CMap","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}}},"_Intent":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.f2py.auxfuncs._Intent","name":"_Intent","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}}},"_ROut":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.f2py.auxfuncs._ROut","name":"_ROut","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}}},"_RT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.f2py.auxfuncs._RT","name":"_RT","upper_bound":"builtins.object","values":[],"variance":0}},"_VT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.f2py.auxfuncs._VT","name":"_VT","upper_bound":"builtins.object","values":[],"variance":0}},"_Var":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.f2py.auxfuncs._Var","name":"_Var","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.f2py.auxfuncs.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.f2py.auxfuncs.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.f2py.auxfuncs.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.f2py.auxfuncs.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.f2py.auxfuncs.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.f2py.auxfuncs.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.f2py.auxfuncs.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"applyrules":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["rules","d","var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.applyrules","name":"applyrules","original_first_arg":"rules","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["rules","d","var"],"arg_types":[{".class":"Instance","args":["builtins.str","builtins.object"],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"Instance","args":["builtins.str","builtins.object"],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"applyrules","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"containscommon":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["rout"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.containscommon","name":"containscommon","original_first_arg":"rout","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["rout"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"containscommon","ret_type":{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"containsderivedtypes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["rout"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.containsderivedtypes","name":"containsderivedtypes","original_first_arg":"rout","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["rout"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"containsderivedtypes","ret_type":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.int","value":0},{".class":"LiteralType","fallback":"builtins.int","value":1}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"debugcapi":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.debugcapi","name":"debugcapi","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"debugcapi","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"dictappend":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["rd","ar"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.dictappend","name":"dictappend","original_first_arg":"rd","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["rd","ar"],"arg_types":[{".class":"Instance","args":["builtins.str","builtins.object"],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","builtins.object"],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"Instance","args":[{".class":"Instance","args":["builtins.str","builtins.object"],"extra_attrs":null,"type_ref":"typing.Mapping"}],"extra_attrs":null,"type_ref":"builtins.list"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dictappend","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"errmess":{".class":"SymbolTableNode","cross_ref":"numpy.f2py.cfuncs.errmess","kind":"Gdef"},"gentitle":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.gentitle","name":"gentitle","original_first_arg":"name","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["name"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"gentitle","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_f2py_modulename":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["source"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.get_f2py_modulename","name":"get_f2py_modulename","original_first_arg":"source","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["source"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.FileDescriptorOrPath"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_f2py_modulename","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"getargs":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["rout"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.getargs","name":"getargs","original_first_arg":"rout","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["rout"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getargs","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"getargs2":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["rout"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.getargs2","name":"getargs2","original_first_arg":"rout","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["rout"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getargs2","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"getcallprotoargument":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["rout","cb_map"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.getcallprotoargument","name":"getcallprotoargument","original_first_arg":"rout","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["rout","cb_map"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getcallprotoargument","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"getcallstatement":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["rout"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.getcallstatement","name":"getcallstatement","original_first_arg":"rout","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["rout"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getcallstatement","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"getdimension":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.getdimension","name":"getdimension","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getdimension","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"getfortranname":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["rout"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.getfortranname","name":"getfortranname","original_first_arg":"rout","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["rout"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getfortranname","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"getmultilineblock":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["rout","blockname","comment","counter"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.getmultilineblock","name":"getmultilineblock","original_first_arg":"rout","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["rout","blockname","comment","counter"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3},"builtins.str",{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getmultilineblock","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"getpymethoddef":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["rout"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.getpymethoddef","name":"getpymethoddef","original_first_arg":"rout","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["rout"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getpymethoddef","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"getrestdoc":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["rout"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.getrestdoc","name":"getrestdoc","original_first_arg":"rout","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["rout"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getrestdoc","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"getuseblocks":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["pymod"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.getuseblocks","name":"getuseblocks","original_first_arg":"pymod","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["pymod"],"arg_types":[{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"typing.Mapping"}],"extra_attrs":null,"type_ref":"typing.Mapping"}],"extra_attrs":null,"type_ref":"typing.Mapping"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getuseblocks","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"getusercode":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["rout"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.getusercode","name":"getusercode","original_first_arg":"rout","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["rout"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getusercode","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"getusercode1":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["rout"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.getusercode1","name":"getusercode1","original_first_arg":"rout","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["rout"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getusercode1","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"hasbody":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["rout"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.hasbody","name":"hasbody","original_first_arg":"rout","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["rout"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hasbody","ret_type":{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"hascallstatement":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["rout"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.hascallstatement","name":"hascallstatement","original_first_arg":"rout","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["rout"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hascallstatement","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"hascommon":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["rout"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.hascommon","name":"hascommon","original_first_arg":"rout","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["rout"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hascommon","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"hasderivedtypes":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["rout"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.hasderivedtypes","name":"hasderivedtypes","original_first_arg":"rout","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["rout"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hasderivedtypes","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"hasexternals":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["rout"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.hasexternals","name":"hasexternals","original_first_arg":"rout","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["rout"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hasexternals","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"hasinitvalue":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.hasinitvalue","name":"hasinitvalue","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3},"builtins.str"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hasinitvalue","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"hasnote":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.hasnote","name":"hasnote","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3},"builtins.str"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hasnote","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"hasresultnote":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["rout"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.hasresultnote","name":"hasresultnote","original_first_arg":"rout","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["rout"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hasresultnote","ret_type":{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isallocatable":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isallocatable","name":"isallocatable","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isallocatable","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isarray":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isarray","name":"isarray","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isarray","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isarrayofstrings":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isarrayofstrings","name":"isarrayofstrings","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isarrayofstrings","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isattr_value":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isattr_value","name":"isattr_value","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isattr_value","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"ischaracter":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.ischaracter","name":"ischaracter","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ischaracter","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"ischaracter_or_characterarray":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.ischaracter_or_characterarray","name":"ischaracter_or_characterarray","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ischaracter_or_characterarray","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"ischaracterarray":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.ischaracterarray","name":"ischaracterarray","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ischaracterarray","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"iscomplex":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.iscomplex","name":"iscomplex","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"iscomplex","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"iscomplexarray":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.iscomplexarray","name":"iscomplexarray","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"iscomplexarray","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"iscomplexfunction":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["rout"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.iscomplexfunction","name":"iscomplexfunction","original_first_arg":"rout","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["rout"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"iscomplexfunction","ret_type":{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"iscomplexfunction_warn":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["rout"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.iscomplexfunction_warn","name":"iscomplexfunction_warn","original_first_arg":"rout","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["rout"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"iscomplexfunction_warn","ret_type":{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"iscstyledirective":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["f2py_line"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.iscstyledirective","name":"iscstyledirective","original_first_arg":"f2py_line","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["f2py_line"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"iscstyledirective","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isdouble":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isdouble","name":"isdouble","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isdouble","ret_type":{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isdummyroutine":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["rout"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isdummyroutine","name":"isdummyroutine","original_first_arg":"rout","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["rout"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isdummyroutine","ret_type":{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isexternal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isexternal","name":"isexternal","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isexternal","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isfunction":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["rout"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isfunction","name":"isfunction","original_first_arg":"rout","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["rout"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isfunction","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isfunction_wrap":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["rout"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isfunction_wrap","name":"isfunction_wrap","original_first_arg":"rout","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["rout"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isfunction_wrap","ret_type":{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isint1":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isint1","name":"isint1","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isint1","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isint1array":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isint1array","name":"isint1array","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isint1array","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isinteger":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isinteger","name":"isinteger","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isinteger","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isintent_aux":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isintent_aux","name":"isintent_aux","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isintent_aux","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isintent_c":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isintent_c","name":"isintent_c","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isintent_c","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isintent_cache":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isintent_cache","name":"isintent_cache","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isintent_cache","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isintent_callback":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isintent_callback","name":"isintent_callback","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isintent_callback","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isintent_copy":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isintent_copy","name":"isintent_copy","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isintent_copy","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isintent_dict":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.f2py.auxfuncs.isintent_dict","name":"isintent_dict","setter_type":null,"type":{".class":"Instance","args":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"isintent_hide":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isintent_hide","name":"isintent_hide","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isintent_hide","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isintent_in":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isintent_in","name":"isintent_in","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isintent_in","ret_type":{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isintent_inout":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isintent_inout","name":"isintent_inout","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isintent_inout","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isintent_inplace":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isintent_inplace","name":"isintent_inplace","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isintent_inplace","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isintent_nothide":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isintent_nothide","name":"isintent_nothide","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isintent_nothide","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isintent_out":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isintent_out","name":"isintent_out","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isintent_out","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isintent_overwrite":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isintent_overwrite","name":"isintent_overwrite","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isintent_overwrite","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"islogical":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.islogical","name":"islogical","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"islogical","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"islogicalfunction":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["rout"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.islogicalfunction","name":"islogicalfunction","original_first_arg":"rout","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["rout"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"islogicalfunction","ret_type":{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"islong_complex":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.islong_complex","name":"islong_complex","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"islong_complex","ret_type":{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"islong_double":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.islong_double","name":"islong_double","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"islong_double","ret_type":{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"islong_doublefunction":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["rout"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.islong_doublefunction","name":"islong_doublefunction","original_first_arg":"rout","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["rout"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"islong_doublefunction","ret_type":{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"islong_long":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.islong_long","name":"islong_long","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"islong_long","ret_type":{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"islong_longfunction":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["rout"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.islong_longfunction","name":"islong_longfunction","original_first_arg":"rout","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["rout"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"islong_longfunction","ret_type":{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"ismodule":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["rout"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.ismodule","name":"ismodule","original_first_arg":"rout","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["rout"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ismodule","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"ismoduleroutine":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["rout"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.ismoduleroutine","name":"ismoduleroutine","original_first_arg":"rout","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["rout"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ismoduleroutine","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isoptional":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isoptional","name":"isoptional","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isoptional","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isprivate":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isprivate","name":"isprivate","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isprivate","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isrequired":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isrequired","name":"isrequired","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isrequired","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isroutine":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["rout"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isroutine","name":"isroutine","original_first_arg":"rout","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["rout"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isroutine","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isscalar":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isscalar","name":"isscalar","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isscalar","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"issigned_long_longarray":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.issigned_long_longarray","name":"issigned_long_longarray","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"issigned_long_longarray","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isstring":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isstring","name":"isstring","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isstring","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isstring_or_stringarray":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isstring_or_stringarray","name":"isstring_or_stringarray","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isstring_or_stringarray","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isstringarray":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isstringarray","name":"isstringarray","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isstringarray","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isstringfunction":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["rout"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isstringfunction","name":"isstringfunction","original_first_arg":"rout","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["rout"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isstringfunction","ret_type":{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"issubroutine":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["rout"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.issubroutine","name":"issubroutine","original_first_arg":"rout","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["rout"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"issubroutine","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"issubroutine_wrap":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["rout"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.issubroutine_wrap","name":"issubroutine_wrap","original_first_arg":"rout","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["rout"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"issubroutine_wrap","ret_type":{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isthreadsafe":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["rout"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isthreadsafe","name":"isthreadsafe","original_first_arg":"rout","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["rout"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isthreadsafe","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isunsigned":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isunsigned","name":"isunsigned","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isunsigned","ret_type":{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isunsigned_char":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isunsigned_char","name":"isunsigned_char","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isunsigned_char","ret_type":{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isunsigned_chararray":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isunsigned_chararray","name":"isunsigned_chararray","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isunsigned_chararray","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isunsigned_long_long":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isunsigned_long_long","name":"isunsigned_long_long","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isunsigned_long_long","ret_type":{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isunsigned_long_longarray":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isunsigned_long_longarray","name":"isunsigned_long_longarray","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isunsigned_long_longarray","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isunsigned_short":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isunsigned_short","name":"isunsigned_short","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isunsigned_short","ret_type":{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isunsigned_shortarray":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isunsigned_shortarray","name":"isunsigned_shortarray","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isunsigned_shortarray","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isvariable":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["var"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.isvariable","name":"isvariable","original_first_arg":"var","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["var"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isvariable","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"l_and":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[2],"arg_names":["f"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.l_and","name":"l_and","original_first_arg":"f","type":{".class":"CallableType","arg_kinds":[2],"arg_names":["f"],"arg_types":[{".class":"TupleType","implicit":false,"items":["builtins.str",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.f2py.auxfuncs._VT","id":-1,"name":"_VT","namespace":"numpy.f2py.auxfuncs.l_and","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.f2py.auxfuncs._RT","id":-2,"name":"_RT","namespace":"numpy.f2py.auxfuncs.l_and","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"l_and","ret_type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.f2py.auxfuncs._VT","id":-1,"name":"_VT","namespace":"numpy.f2py.auxfuncs.l_and","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.f2py.auxfuncs._RT","id":-2,"name":"_RT","namespace":"numpy.f2py.auxfuncs.l_and","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.f2py.auxfuncs._VT","id":-1,"name":"_VT","namespace":"numpy.f2py.auxfuncs.l_and","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.f2py.auxfuncs._RT","id":-2,"name":"_RT","namespace":"numpy.f2py.auxfuncs.l_and","upper_bound":"builtins.object","values":[],"variance":0}]}}},"l_not":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["f"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.l_not","name":"l_not","original_first_arg":"f","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["f"],"arg_types":[{".class":"TupleType","implicit":false,"items":["builtins.str",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.f2py.auxfuncs._VT","id":-1,"name":"_VT","namespace":"numpy.f2py.auxfuncs.l_not","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.f2py.auxfuncs._RT","id":-2,"name":"_RT","namespace":"numpy.f2py.auxfuncs.l_not","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"l_not","ret_type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.f2py.auxfuncs._VT","id":-1,"name":"_VT","namespace":"numpy.f2py.auxfuncs.l_not","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.f2py.auxfuncs._RT","id":-2,"name":"_RT","namespace":"numpy.f2py.auxfuncs.l_not","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.f2py.auxfuncs._VT","id":-1,"name":"_VT","namespace":"numpy.f2py.auxfuncs.l_not","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.f2py.auxfuncs._RT","id":-2,"name":"_RT","namespace":"numpy.f2py.auxfuncs.l_not","upper_bound":"builtins.object","values":[],"variance":0}]}}},"l_or":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[2],"arg_names":["f"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.l_or","name":"l_or","original_first_arg":"f","type":{".class":"CallableType","arg_kinds":[2],"arg_names":["f"],"arg_types":[{".class":"TupleType","implicit":false,"items":["builtins.str",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.f2py.auxfuncs._VT","id":-1,"name":"_VT","namespace":"numpy.f2py.auxfuncs.l_or","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.f2py.auxfuncs._RT","id":-2,"name":"_RT","namespace":"numpy.f2py.auxfuncs.l_or","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"l_or","ret_type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.f2py.auxfuncs._VT","id":-1,"name":"_VT","namespace":"numpy.f2py.auxfuncs.l_or","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.f2py.auxfuncs._RT","id":-2,"name":"_RT","namespace":"numpy.f2py.auxfuncs.l_or","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.f2py.auxfuncs._VT","id":-1,"name":"_VT","namespace":"numpy.f2py.auxfuncs.l_or","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.f2py.auxfuncs._RT","id":-2,"name":"_RT","namespace":"numpy.f2py.auxfuncs.l_or","upper_bound":"builtins.object","values":[],"variance":0}]}}},"outmess":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["t"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.outmess","name":"outmess","original_first_arg":"t","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["t"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outmess","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false},"process_f2cmap_dict":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["f2cmap_all","new_map","c2py_map","verbose"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.process_f2cmap_dict","name":"process_f2cmap_dict","original_first_arg":"f2cmap_all","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["f2cmap_all","new_map","c2py_map","verbose"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"process_f2cmap_dict","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"replace":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.replace","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["str","d","defaultsep"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.f2py.auxfuncs.replace","name":"replace","original_first_arg":"str","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["str","d","defaultsep"],"arg_types":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.f2py.auxfuncs.replace","name":"replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["str","d","defaultsep"],"arg_types":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["str","d","defaultsep"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.f2py.auxfuncs.replace","name":"replace","original_first_arg":"str","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["str","d","defaultsep"],"arg_types":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},"builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.f2py.auxfuncs.replace","name":"replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["str","d","defaultsep"],"arg_types":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},"builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["str","d","defaultsep"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.f2py.auxfuncs.replace","name":"replace","original_first_arg":"str","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["str","d","defaultsep"],"arg_types":["builtins.str","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.f2py.auxfuncs.replace","name":"replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["str","d","defaultsep"],"arg_types":["builtins.str","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["str","d","defaultsep"],"arg_types":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["str","d","defaultsep"],"arg_types":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},"builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["str","d","defaultsep"],"arg_types":["builtins.str","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"show":{".class":"SymbolTableNode","cross_ref":"pprint.pprint","kind":"Gdef"},"stripcomma":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["s"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.stripcomma","name":"stripcomma","original_first_arg":"s","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["s"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"stripcomma","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"throw_error":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.f2py.auxfuncs.throw_error","name":"throw_error","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.f2py.auxfuncs.throw_error","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.f2py.auxfuncs","mro":["numpy.f2py.auxfuncs.throw_error","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"var"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.f2py.auxfuncs.throw_error.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"var"],"arg_types":["numpy.f2py.auxfuncs.throw_error",{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of throw_error","ret_type":{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.Never","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"mess"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.f2py.auxfuncs.throw_error.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"mess"],"arg_types":["numpy.f2py.auxfuncs.throw_error","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of throw_error","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"mess":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","final_unset_in_class","is_ready"],"fullname":"numpy.f2py.auxfuncs.throw_error.mess","name":"mess","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.f2py.auxfuncs.throw_error.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.f2py.auxfuncs.throw_error","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/f2py/auxfuncs.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/f2py/auxfuncs.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/f2py/auxfuncs.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..b7a0a81e25de63b4edf82ee968da217b66ef8c08 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/f2py/auxfuncs.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[8,1,2,3,6,1,1,1,1],"dep_prios":[5,5,5,5,5,5,30,30,30],"dependencies":["numpy.f2py.cfuncs","collections.abc","pprint","typing","_typeshed","builtins","_frozen_importlib","abc","os"],"hash":"7e5678c3f8d7fd14e93a649a79eb1d1a4ad7ca07","id":"numpy.f2py.auxfuncs","ignore_all":true,"interface_hash":"26b676eec088a5f06b9eb9e156ff21a0dbe30d09","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/f2py/auxfuncs.pyi","plugin_data":null,"size":8011,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/f2py/cfuncs.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/f2py/cfuncs.data.json new file mode 100644 index 0000000000000000000000000000000000000000..9b2fa401261e8ee0a977b3c1826be86e2d571011 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/f2py/cfuncs.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.f2py.cfuncs","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Final":{".class":"SymbolTableNode","cross_ref":"typing.Final","kind":"Gdef","module_hidden":true,"module_public":false},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.f2py.cfuncs.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.f2py.cfuncs.TypeAlias","source_any":null,"type_of_any":3}}},"_NeedDict":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.f2py.cfuncs._NeedDict","name":"_NeedDict","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.f2py.cfuncs.TypeAlias","source_any":null,"type_of_any":3}}},"_NeedListDict":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.f2py.cfuncs._NeedListDict","name":"_NeedListDict","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.f2py.cfuncs.TypeAlias","source_any":null,"type_of_any":3}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.f2py.cfuncs.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.f2py.cfuncs.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.f2py.cfuncs.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.f2py.cfuncs.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.f2py.cfuncs.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.f2py.cfuncs.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"append_needs":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["need","flag"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.cfuncs.append_needs","name":"append_needs","original_first_arg":"need","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["need","flag"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],"uses_pep604_syntax":true},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"append_needs","ret_type":{".class":"AnyType","missing_import_name":"numpy.f2py.cfuncs.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"buildcfuncs":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.cfuncs.buildcfuncs","name":"buildcfuncs","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"buildcfuncs","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"callbacks":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.f2py.cfuncs.callbacks","name":"callbacks","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.f2py.cfuncs.TypeAlias","source_any":null,"type_of_any":3}}},"cfuncs":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.f2py.cfuncs.cfuncs","name":"cfuncs","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.f2py.cfuncs.TypeAlias","source_any":null,"type_of_any":3}}},"commonhooks":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.f2py.cfuncs.commonhooks","name":"commonhooks","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.f2py.cfuncs.TypeAlias","source_any":null,"type_of_any":3}}},"cppmacros":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.f2py.cfuncs.cppmacros","name":"cppmacros","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.f2py.cfuncs.TypeAlias","source_any":null,"type_of_any":3}}},"errmess":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["s"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.cfuncs.errmess","name":"errmess","original_first_arg":"s","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["s"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"errmess","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"f2py_version":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.f2py.cfuncs.f2py_version","name":"f2py_version","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.version.LiteralString","source_any":null,"type_of_any":3}}},"f90modhooks":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.f2py.cfuncs.f90modhooks","name":"f90modhooks","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.f2py.cfuncs.TypeAlias","source_any":null,"type_of_any":3}}},"get_needs":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.cfuncs.get_needs","name":"get_needs","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_needs","ret_type":{".class":"AnyType","missing_import_name":"numpy.f2py.cfuncs.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"includes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.f2py.cfuncs.includes","name":"includes","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.f2py.cfuncs.TypeAlias","source_any":null,"type_of_any":3}}},"includes0":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.f2py.cfuncs.includes0","name":"includes0","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.f2py.cfuncs.TypeAlias","source_any":null,"type_of_any":3}}},"needs":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.f2py.cfuncs.needs","name":"needs","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.f2py.cfuncs.TypeAlias","source_any":null,"type_of_any":3}}},"outneeds":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.f2py.cfuncs.outneeds","name":"outneeds","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.f2py.cfuncs.TypeAlias","source_any":null,"type_of_any":3}}},"typedefs":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.f2py.cfuncs.typedefs","name":"typedefs","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.f2py.cfuncs.TypeAlias","source_any":null,"type_of_any":3}}},"typedefs_generated":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.f2py.cfuncs.typedefs_generated","name":"typedefs_generated","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.f2py.cfuncs.TypeAlias","source_any":null,"type_of_any":3}}},"userincludes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.f2py.cfuncs.userincludes","name":"userincludes","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.f2py.cfuncs.TypeAlias","source_any":null,"type_of_any":3}}},"version":{".class":"SymbolTableNode","cross_ref":"numpy.version.version","kind":"Gdef","module_hidden":true,"module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/f2py/cfuncs.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/f2py/cfuncs.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/f2py/cfuncs.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..347d226ea2d9563d6e1d34489d494df89635cd50 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/f2py/cfuncs.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106714,"dep_lines":[3,1,1,1,1,1,1],"dep_prios":[5,5,5,30,30,30,30],"dependencies":["numpy.f2py.__version__","typing","builtins","_frozen_importlib","_typeshed","abc","numpy.version"],"hash":"c102b232b727e1547a66c0c3015d6e0a86567f23","id":"numpy.f2py.cfuncs","ignore_all":true,"interface_hash":"390960e9081c926c4120cbebf64b869d2deb932d","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/f2py/cfuncs.pyi","plugin_data":null,"size":802,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/f2py/f2py2e.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/f2py/f2py2e.data.json new file mode 100644 index 0000000000000000000000000000000000000000..42387c9bbb7672a6e57b408ae7a86eeabf27d1ad --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/f2py/f2py2e.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.f2py.f2py2e","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"CombineIncludePaths":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["argparse.Action"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.f2py.f2py2e.CombineIncludePaths","name":"CombineIncludePaths","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.f2py.f2py2e.CombineIncludePaths","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.f2py.f2py2e","mro":["numpy.f2py.f2py2e.CombineIncludePaths","argparse.Action","argparse._AttributeHolder","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1],"arg_names":[null,"parser","namespace","values","option_string"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated","is_trivial_self"],"fullname":"numpy.f2py.f2py2e.CombineIncludePaths.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":[null,"parser","namespace","values","option_string"],"arg_types":["numpy.f2py.f2py2e.CombineIncludePaths","argparse.ArgumentParser","argparse.Namespace",{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of CombineIncludePaths","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred"],"fullname":"numpy.f2py.f2py2e.CombineIncludePaths.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":[null,"parser","namespace","values","option_string"],"arg_types":["numpy.f2py.f2py2e.CombineIncludePaths","argparse.ArgumentParser","argparse.Namespace",{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of CombineIncludePaths","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.f2py.f2py2e.CombineIncludePaths.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.f2py.f2py2e.CombineIncludePaths","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Final":{".class":"SymbolTableNode","cross_ref":"typing.Final","kind":"Gdef","module_hidden":true,"module_public":false},"Hashable":{".class":"SymbolTableNode","cross_ref":"typing.Hashable","kind":"Gdef","module_hidden":true,"module_public":false},"Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef","module_hidden":true,"module_public":false},"MESON_ONLY_VER":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy.f2py.f2py2e.MESON_ONLY_VER","name":"MESON_ONLY_VER","setter_type":null,"type":"builtins.bool"}},"Mapping":{".class":"SymbolTableNode","cross_ref":"typing.Mapping","kind":"Gdef","module_hidden":true,"module_public":false},"ModuleType":{".class":"SymbolTableNode","cross_ref":"types.ModuleType","kind":"Gdef","module_hidden":true,"module_public":false},"MutableMapping":{".class":"SymbolTableNode","cross_ref":"typing.MutableMapping","kind":"Gdef","module_hidden":true,"module_public":false},"NotRequired":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.f2py.f2py2e.NotRequired","name":"NotRequired","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.f2py.f2py2e.NotRequired","source_any":null,"type_of_any":3}}},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef","module_hidden":true,"module_public":false},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing_extensions.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"TypedDict":{".class":"SymbolTableNode","cross_ref":"typing.TypedDict","kind":"Gdef","module_hidden":true,"module_public":false},"_Bool":{".class":"SymbolTableNode","cross_ref":"numpy.f2py.auxfuncs._Bool","kind":"Gdef","module_hidden":true,"module_public":false},"_F2PyDict":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.f2py.f2py2e._F2PyDict","name":"_F2PyDict","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.f2py.f2py2e._F2PyDict","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.f2py.f2py2e","mro":["numpy.f2py.f2py2e._F2PyDict","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["csrc",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],["h",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],["fsrc",{".class":"AnyType","missing_import_name":"numpy.f2py.f2py2e.NotRequired","source_any":null,"type_of_any":3}],["ltx",{".class":"AnyType","missing_import_name":"numpy.f2py.f2py2e.NotRequired","source_any":null,"type_of_any":3}]],"readonly_keys":[],"required_keys":["csrc","fsrc","h","ltx"]}}},"_KT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.f2py.f2py2e._KT","name":"_KT","upper_bound":"typing.Hashable","values":[],"variance":0}},"_PreparseResult":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.f2py.f2py2e._PreparseResult","name":"_PreparseResult","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.f2py.f2py2e._PreparseResult","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.f2py.f2py2e","mro":["numpy.f2py.f2py2e._PreparseResult","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["dependencies",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],["backend","builtins.str"],["modulename","builtins.str"]],"readonly_keys":[],"required_keys":["backend","dependencies","modulename"]}}},"_VT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.f2py.f2py2e._VT","name":"_VT","upper_bound":"builtins.object","values":[],"variance":0}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.f2py.f2py2e.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.f2py.f2py2e.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.f2py.f2py2e.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.f2py.f2py2e.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.f2py.f2py2e.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.f2py.f2py2e.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"__usage__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy.f2py.f2py2e.__usage__","name":"__usage__","setter_type":null,"type":"builtins.str"}},"argparse":{".class":"SymbolTableNode","cross_ref":"argparse","kind":"Gdef","module_hidden":true,"module_public":false},"buildmodules":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["lst"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.f2py2e.buildmodules","name":"buildmodules","original_first_arg":"lst","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["lst"],"arg_types":[{".class":"Instance","args":[{".class":"Instance","args":["builtins.str","builtins.object"],"extra_attrs":null,"type_ref":"typing.Mapping"}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"buildmodules","ret_type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"callcrackfortran":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["files","options"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.f2py2e.callcrackfortran","name":"callcrackfortran","original_first_arg":"files","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["files","options"],"arg_types":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":["builtins.str","builtins.bool"],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"callcrackfortran","ret_type":{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"dict_append":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["d_out","d_in"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.f2py2e.dict_append","name":"dict_append","original_first_arg":"d_out","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["d_out","d_in"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.f2py.f2py2e._KT","id":-1,"name":"_KT","namespace":"numpy.f2py.f2py2e.dict_append","upper_bound":"typing.Hashable","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.f2py.f2py2e._VT","id":-2,"name":"_VT","namespace":"numpy.f2py.f2py2e.dict_append","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"typing.MutableMapping"},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.f2py.f2py2e._KT","id":-1,"name":"_KT","namespace":"numpy.f2py.f2py2e.dict_append","upper_bound":"typing.Hashable","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.f2py.f2py2e._VT","id":-2,"name":"_VT","namespace":"numpy.f2py.f2py2e.dict_append","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"typing.Mapping"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dict_append","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.f2py.f2py2e._KT","id":-1,"name":"_KT","namespace":"numpy.f2py.f2py2e.dict_append","upper_bound":"typing.Hashable","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.f2py.f2py2e._VT","id":-2,"name":"_VT","namespace":"numpy.f2py.f2py2e.dict_append","upper_bound":"builtins.object","values":[],"variance":0}]}}},"f2py_parser":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.f2py2e.f2py_parser","name":"f2py_parser","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"f2py_parser","ret_type":"argparse.ArgumentParser","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"f2py_version":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.f2py.f2py2e.f2py_version","name":"f2py_version","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.version.LiteralString","source_any":null,"type_of_any":3}}},"filter_files":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["prefix","suffix","files","remove_prefix"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.f2py2e.filter_files","name":"filter_files","original_first_arg":"prefix","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["prefix","suffix","files","remove_prefix"],"arg_types":["builtins.str","builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"filter_files","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_newer_options":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["iline"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.f2py2e.get_newer_options","name":"get_newer_options","original_first_arg":"iline","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["iline"],"arg_types":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_newer_options","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_prefix":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["module"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.f2py2e.get_prefix","name":"get_prefix","original_first_arg":"module","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["module"],"arg_types":["types.ModuleType"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_prefix","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"main":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.f2py2e.main","name":"main","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"main","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"make_f2py_compile_parser":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.f2py2e.make_f2py_compile_parser","name":"make_f2py_compile_parser","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"make_f2py_compile_parser","ret_type":"argparse.ArgumentParser","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"numpy_version":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.f2py.f2py2e.numpy_version","name":"numpy_version","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.version.LiteralString","source_any":null,"type_of_any":3}}},"outmess":{".class":"SymbolTableNode","cross_ref":"numpy.f2py.auxfuncs.outmess","kind":"Gdef"},"override":{".class":"SymbolTableNode","cross_ref":"typing_extensions.override","kind":"Gdef","module_hidden":true,"module_public":false},"pprint":{".class":"SymbolTableNode","cross_ref":"pprint","kind":"Gdef","module_hidden":true,"module_public":false},"preparse_sysargv":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.f2py2e.preparse_sysargv","name":"preparse_sysargv","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"preparse_sysargv","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.f2py.f2py2e._PreparseResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"run_compile":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.f2py2e.run_compile","name":"run_compile","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"run_compile","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"run_main":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["comline_list"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.f2py2e.run_main","name":"run_main","original_first_arg":"comline_list","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["comline_list"],"arg_types":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"run_main","ret_type":{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"numpy.f2py.f2py2e._F2PyDict"}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"scaninputline":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["inputline"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.f2py2e.scaninputline","name":"scaninputline","original_first_arg":"inputline","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["inputline"],"arg_types":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"scaninputline","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":"numpy.f2py.auxfuncs.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.dict"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"show":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.f2py.f2py2e.show","name":"show","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5,5],"arg_names":["object","stream","indent","width","depth","compact","sort_dicts"],"arg_types":["builtins.object",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.IO"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"type_check_only":{".class":"SymbolTableNode","cross_ref":"typing.type_check_only","kind":"Gdef","module_hidden":true,"module_public":false},"validate_modulename":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["pyf_files","modulename"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.f2py.f2py2e.validate_modulename","name":"validate_modulename","original_first_arg":"pyf_files","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["pyf_files","modulename"],"arg_types":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate_modulename","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"version":{".class":"SymbolTableNode","cross_ref":"numpy.version.version","kind":"Gdef","module_hidden":true,"module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/f2py/f2py2e.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/f2py/f2py2e.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/f2py/f2py2e.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..7157834bd741d041ae77e526dde554723c7d1b51 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/f2py/f2py2e.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[9,10,3,1,2,4,5,7,1,1,1,1],"dep_prios":[5,5,5,10,10,5,5,5,5,30,30,30],"dependencies":["numpy.f2py.__version__","numpy.f2py.auxfuncs","collections.abc","argparse","pprint","types","typing","typing_extensions","builtins","_frozen_importlib","abc","numpy.version"],"hash":"8342fb5edd656dc5e0e5a9badd819f5371263488","id":"numpy.f2py.f2py2e","ignore_all":true,"interface_hash":"09edd41cb85e1bd217e6ade90b6323334cab901b","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/f2py/f2py2e.pyi","plugin_data":null,"size":2153,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/fft/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/fft/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..4c6b3277b5bec35f862fce6635a4415fe78608e2 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/fft/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.fft","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.fft.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.fft.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.fft.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.fft.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.fft.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.fft.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.fft.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.fft.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"fft":{".class":"SymbolTableNode","cross_ref":"numpy.fft._pocketfft.fft","kind":"Gdef"},"fft2":{".class":"SymbolTableNode","cross_ref":"numpy.fft._pocketfft.fft2","kind":"Gdef"},"fftfreq":{".class":"SymbolTableNode","cross_ref":"numpy.fft._helper.fftfreq","kind":"Gdef"},"fftn":{".class":"SymbolTableNode","cross_ref":"numpy.fft._pocketfft.fftn","kind":"Gdef"},"fftshift":{".class":"SymbolTableNode","cross_ref":"numpy.fft._helper.fftshift","kind":"Gdef"},"hfft":{".class":"SymbolTableNode","cross_ref":"numpy.fft._pocketfft.hfft","kind":"Gdef"},"ifft":{".class":"SymbolTableNode","cross_ref":"numpy.fft._pocketfft.ifft","kind":"Gdef"},"ifft2":{".class":"SymbolTableNode","cross_ref":"numpy.fft._pocketfft.ifft2","kind":"Gdef"},"ifftn":{".class":"SymbolTableNode","cross_ref":"numpy.fft._pocketfft.ifftn","kind":"Gdef"},"ifftshift":{".class":"SymbolTableNode","cross_ref":"numpy.fft._helper.ifftshift","kind":"Gdef"},"ihfft":{".class":"SymbolTableNode","cross_ref":"numpy.fft._pocketfft.ihfft","kind":"Gdef"},"irfft":{".class":"SymbolTableNode","cross_ref":"numpy.fft._pocketfft.irfft","kind":"Gdef"},"irfft2":{".class":"SymbolTableNode","cross_ref":"numpy.fft._pocketfft.irfft2","kind":"Gdef"},"irfftn":{".class":"SymbolTableNode","cross_ref":"numpy.fft._pocketfft.irfftn","kind":"Gdef"},"rfft":{".class":"SymbolTableNode","cross_ref":"numpy.fft._pocketfft.rfft","kind":"Gdef"},"rfft2":{".class":"SymbolTableNode","cross_ref":"numpy.fft._pocketfft.rfft2","kind":"Gdef"},"rfftfreq":{".class":"SymbolTableNode","cross_ref":"numpy.fft._helper.rfftfreq","kind":"Gdef"},"rfftn":{".class":"SymbolTableNode","cross_ref":"numpy.fft._pocketfft.rfftn","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/fft/__init__.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/fft/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/fft/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..92224b5abbe98204eba3ac6e8bbff8ea58e4b347 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/fft/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,7,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["numpy.fft._helper","numpy.fft._pocketfft","builtins","_frozen_importlib","abc","typing"],"hash":"66292d2da60218b5eaf903b88be2b190f979c03a","id":"numpy.fft","ignore_all":true,"interface_hash":"b32141efd045e05f06487c296a2130378af2f028","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/fft/__init__.pyi","plugin_data":null,"size":514,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/fft/_helper.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/fft/_helper.data.json new file mode 100644 index 0000000000000000000000000000000000000000..658627a6a7c3ba7e334990f743fb7754d5561e24 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/fft/_helper.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.fft._helper","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"Final":{".class":"SymbolTableNode","cross_ref":"typing.Final","kind":"Gdef","module_hidden":true,"module_public":false},"L":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeComplex_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeComplex_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeFloat_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeFloat_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ScalarT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.fft._helper._ScalarT","name":"_ScalarT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},"_ShapeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._shape._ShapeLike","kind":"Gdef","module_hidden":true,"module_public":false},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.fft._helper.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.fft._helper.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.fft._helper.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.fft._helper.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.fft._helper.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.fft._helper.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.fft._helper.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"complexfloating":{".class":"SymbolTableNode","cross_ref":"numpy.complexfloating","kind":"Gdef","module_hidden":true,"module_public":false},"fftfreq":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.fft._helper.fftfreq","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["n","d","device"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.fft._helper.fftfreq","name":"fftfreq","original_first_arg":"n","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["n","d","device"],"arg_types":[{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fftfreq","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.fft._helper.fftfreq","name":"fftfreq","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["n","d","device"],"arg_types":[{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fftfreq","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["n","d","device"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.fft._helper.fftfreq","name":"fftfreq","original_first_arg":"n","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["n","d","device"],"arg_types":[{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fftfreq","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.fft._helper.fftfreq","name":"fftfreq","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["n","d","device"],"arg_types":[{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fftfreq","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["n","d","device"],"arg_types":[{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fftfreq","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["n","d","device"],"arg_types":[{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fftfreq","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"fftshift":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.fft._helper.fftshift","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["x","axes"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.fft._helper.fftshift","name":"fftshift","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["x","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fftshift","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.fft._helper._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.fft._helper.fftshift#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.fft._helper.fftshift","name":"fftshift","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["x","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fftshift","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.fft._helper._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.fft._helper.fftshift#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["x","axes"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.fft._helper.fftshift","name":"fftshift","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["x","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fftshift","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.fft._helper.fftshift","name":"fftshift","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["x","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fftshift","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["x","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fftshift","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.fft._helper._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.fft._helper.fftshift#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["x","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fftshift","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"floating":{".class":"SymbolTableNode","cross_ref":"numpy.floating","kind":"Gdef","module_hidden":true,"module_public":false},"generic":{".class":"SymbolTableNode","cross_ref":"numpy.generic","kind":"Gdef","module_hidden":true,"module_public":false},"ifftshift":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.fft._helper.ifftshift","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["x","axes"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.fft._helper.ifftshift","name":"ifftshift","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["x","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ifftshift","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.fft._helper._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.fft._helper.ifftshift#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.fft._helper.ifftshift","name":"ifftshift","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["x","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ifftshift","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.fft._helper._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.fft._helper.ifftshift#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["x","axes"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.fft._helper.ifftshift","name":"ifftshift","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["x","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ifftshift","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.fft._helper.ifftshift","name":"ifftshift","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["x","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ifftshift","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["x","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ifftshift","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.fft._helper._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.fft._helper.ifftshift#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["x","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ifftshift","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"integer":{".class":"SymbolTableNode","cross_ref":"numpy.integer","kind":"Gdef","module_hidden":true,"module_public":false},"integer_types":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.fft._helper.integer_types","name":"integer_types","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":[{".class":"TypeType","item":"builtins.int"},{".class":"TypeType","item":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"}}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false},"rfftfreq":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.fft._helper.rfftfreq","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["n","d","device"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.fft._helper.rfftfreq","name":"rfftfreq","original_first_arg":"n","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["n","d","device"],"arg_types":[{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rfftfreq","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.fft._helper.rfftfreq","name":"rfftfreq","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["n","d","device"],"arg_types":[{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rfftfreq","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["n","d","device"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.fft._helper.rfftfreq","name":"rfftfreq","original_first_arg":"n","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["n","d","device"],"arg_types":[{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rfftfreq","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.fft._helper.rfftfreq","name":"rfftfreq","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["n","d","device"],"arg_types":[{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rfftfreq","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["n","d","device"],"arg_types":[{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rfftfreq","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["n","d","device"],"arg_types":[{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rfftfreq","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/fft/_helper.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/fft/_helper.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/fft/_helper.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..176f1cdf6c82a62c0d41345fa4e2b6d3e66075f3 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/fft/_helper.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[5,1,4,1,1,1],"dep_prios":[5,5,5,5,30,30],"dependencies":["numpy._typing","typing","numpy","builtins","_frozen_importlib","abc"],"hash":"520a28336cdff10948d09c31c483dda5d28ee443","id":"numpy.fft._helper","ignore_all":true,"interface_hash":"ad3eb63a21dfd6096e1b4660e6bbaf14d02a7f09","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/fft/_helper.pyi","plugin_data":null,"size":1394,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/fft/_pocketfft.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/fft/_pocketfft.data.json new file mode 100644 index 0000000000000000000000000000000000000000..a48ca00089c1b314610eed596036003c55608eee --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/fft/_pocketfft.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.fft._pocketfft","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"L":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef","module_hidden":true,"module_public":false},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.fft._pocketfft.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.fft._pocketfft.TypeAlias","source_any":null,"type_of_any":3}}},"_ArrayLikeNumber_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeNumber_co","kind":"Gdef","module_hidden":true,"module_public":false},"_NormKind":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.fft._pocketfft._NormKind","name":"_NormKind","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.fft._pocketfft.TypeAlias","source_any":null,"type_of_any":3}}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.fft._pocketfft.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.fft._pocketfft.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.fft._pocketfft.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.fft._pocketfft.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.fft._pocketfft.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.fft._pocketfft.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.fft._pocketfft.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"complex128":{".class":"SymbolTableNode","cross_ref":"numpy.complex128","kind":"Gdef","module_hidden":true,"module_public":false},"fft":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["a","n","axis","norm","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.fft._pocketfft.fft","name":"fft","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","n","axis","norm","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"AnyType","missing_import_name":"numpy.fft._pocketfft.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fft","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"fft2":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["a","s","axes","norm","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.fft._pocketfft.fft2","name":"fft2","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","s","axes","norm","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.fft._pocketfft.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fft2","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"fftn":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["a","s","axes","norm","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.fft._pocketfft.fftn","name":"fftn","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","s","axes","norm","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.fft._pocketfft.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fftn","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"float64":{".class":"SymbolTableNode","cross_ref":"numpy.float64","kind":"Gdef","module_hidden":true,"module_public":false},"hfft":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["a","n","axis","norm","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.fft._pocketfft.hfft","name":"hfft","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","n","axis","norm","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"AnyType","missing_import_name":"numpy.fft._pocketfft.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hfft","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"ifft":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["a","n","axis","norm","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.fft._pocketfft.ifft","name":"ifft","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","n","axis","norm","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"AnyType","missing_import_name":"numpy.fft._pocketfft.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ifft","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"ifft2":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["a","s","axes","norm","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.fft._pocketfft.ifft2","name":"ifft2","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","s","axes","norm","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.fft._pocketfft.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ifft2","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"ifftn":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["a","s","axes","norm","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.fft._pocketfft.ifftn","name":"ifftn","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","s","axes","norm","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.fft._pocketfft.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ifftn","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"ihfft":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["a","n","axis","norm","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.fft._pocketfft.ihfft","name":"ihfft","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","n","axis","norm","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"AnyType","missing_import_name":"numpy.fft._pocketfft.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ihfft","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"irfft":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["a","n","axis","norm","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.fft._pocketfft.irfft","name":"irfft","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","n","axis","norm","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"AnyType","missing_import_name":"numpy.fft._pocketfft.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"irfft","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"irfft2":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["a","s","axes","norm","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.fft._pocketfft.irfft2","name":"irfft2","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","s","axes","norm","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.fft._pocketfft.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"irfft2","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"irfftn":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["a","s","axes","norm","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.fft._pocketfft.irfftn","name":"irfftn","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","s","axes","norm","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.fft._pocketfft.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"irfftn","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"rfft":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["a","n","axis","norm","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.fft._pocketfft.rfft","name":"rfft","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","n","axis","norm","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"AnyType","missing_import_name":"numpy.fft._pocketfft.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rfft","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"rfft2":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["a","s","axes","norm","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.fft._pocketfft.rfft2","name":"rfft2","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","s","axes","norm","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.fft._pocketfft.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rfft2","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"rfftn":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["a","s","axes","norm","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.fft._pocketfft.rfftn","name":"rfftn","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","s","axes","norm","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.fft._pocketfft.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rfftn","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/fft/_pocketfft.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/fft/_pocketfft.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/fft/_pocketfft.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..f2a48760b1dcbb4c0b74b3c0cff85463ce66c7ea --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/fft/_pocketfft.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,6,2,5,1,1,1],"dep_prios":[5,5,5,5,5,30,30],"dependencies":["collections.abc","numpy._typing","typing","numpy","builtins","_frozen_importlib","abc"],"hash":"9cda183606ac43243ca03e53f66d3bc07bf0cca3","id":"numpy.fft._pocketfft","ignore_all":true,"interface_hash":"fe3f67dbd24686fc0bb123cc58118cbb0166ba16","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/fft/_pocketfft.pyi","plugin_data":null,"size":3174,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..a3c463be1feeb23160651aaca7ffa9f1f196e3a9 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.lib","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Arrayterator":{".class":"SymbolTableNode","cross_ref":"numpy.lib._arrayterator_impl.Arrayterator","kind":"Gdef"},"NumpyVersion":{".class":"SymbolTableNode","cross_ref":"numpy.lib._version.NumpyVersion","kind":"Gdef"},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_array_utils_impl":{".class":"SymbolTableNode","cross_ref":"numpy.lib._array_utils_impl","kind":"Gdef","module_public":false},"_arraypad_impl":{".class":"SymbolTableNode","cross_ref":"numpy.lib._arraypad_impl","kind":"Gdef","module_public":false},"_arraysetops_impl":{".class":"SymbolTableNode","cross_ref":"numpy.lib._arraysetops_impl","kind":"Gdef","module_public":false},"_arrayterator_impl":{".class":"SymbolTableNode","cross_ref":"numpy.lib._arrayterator_impl","kind":"Gdef","module_public":false},"_datasource":{".class":"SymbolTableNode","cross_ref":"numpy.lib._datasource","kind":"Gdef","module_public":false},"_format_impl":{".class":"SymbolTableNode","cross_ref":"numpy.lib._format_impl","kind":"Gdef","module_public":false},"_function_base_impl":{".class":"SymbolTableNode","cross_ref":"numpy.lib._function_base_impl","kind":"Gdef","module_public":false},"_histograms_impl":{".class":"SymbolTableNode","cross_ref":"numpy.lib._histograms_impl","kind":"Gdef","module_public":false},"_index_tricks_impl":{".class":"SymbolTableNode","cross_ref":"numpy.lib._index_tricks_impl","kind":"Gdef","module_public":false},"_iotools":{".class":"SymbolTableNode","cross_ref":"numpy.lib._iotools","kind":"Gdef","module_public":false},"_nanfunctions_impl":{".class":"SymbolTableNode","cross_ref":"numpy.lib._nanfunctions_impl","kind":"Gdef","module_public":false},"_npyio_impl":{".class":"SymbolTableNode","cross_ref":"numpy.lib._npyio_impl","kind":"Gdef","module_public":false},"_polynomial_impl":{".class":"SymbolTableNode","cross_ref":"numpy.lib._polynomial_impl","kind":"Gdef","module_public":false},"_scimath_impl":{".class":"SymbolTableNode","cross_ref":"numpy.lib._scimath_impl","kind":"Gdef","module_public":false},"_shape_base_impl":{".class":"SymbolTableNode","cross_ref":"numpy.lib._shape_base_impl","kind":"Gdef","module_public":false},"_stride_tricks_impl":{".class":"SymbolTableNode","cross_ref":"numpy.lib._stride_tricks_impl","kind":"Gdef","module_public":false},"_twodim_base_impl":{".class":"SymbolTableNode","cross_ref":"numpy.lib._twodim_base_impl","kind":"Gdef","module_public":false},"_type_check_impl":{".class":"SymbolTableNode","cross_ref":"numpy.lib._type_check_impl","kind":"Gdef","module_public":false},"_ufunclike_impl":{".class":"SymbolTableNode","cross_ref":"numpy.lib._ufunclike_impl","kind":"Gdef","module_public":false},"_utils_impl":{".class":"SymbolTableNode","cross_ref":"numpy.lib._utils_impl","kind":"Gdef","module_public":false},"_version":{".class":"SymbolTableNode","cross_ref":"numpy.lib._version","kind":"Gdef","module_public":false},"add_docstring":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.add_docstring","kind":"Gdef"},"add_newdoc":{".class":"SymbolTableNode","cross_ref":"numpy._core.function_base.add_newdoc","kind":"Gdef"},"array_utils":{".class":"SymbolTableNode","cross_ref":"numpy.lib.array_utils","kind":"Gdef"},"format":{".class":"SymbolTableNode","cross_ref":"numpy.lib.format","kind":"Gdef"},"introspect":{".class":"SymbolTableNode","cross_ref":"numpy.lib.introspect","kind":"Gdef"},"mixins":{".class":"SymbolTableNode","cross_ref":"numpy.lib.mixins","kind":"Gdef"},"npyio":{".class":"SymbolTableNode","cross_ref":"numpy.lib.npyio","kind":"Gdef"},"scimath":{".class":"SymbolTableNode","cross_ref":"numpy.lib.scimath","kind":"Gdef"},"stride_tricks":{".class":"SymbolTableNode","cross_ref":"numpy.lib.stride_tricks","kind":"Gdef"},"tracemalloc_domain":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.tracemalloc_domain","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/__init__.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..d850468adf605f39a759e991b53935faa49f0079 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,2,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,27,27,27,27,27,27,1,1,1,1],"dep_prios":[5,5,10,10,10,5,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,5,10,10,10,10,10,10,10,5,30,30,30],"dependencies":["numpy._core.function_base","numpy._core.multiarray","numpy.lib._array_utils_impl","numpy.lib._arraypad_impl","numpy.lib._arraysetops_impl","numpy.lib._arrayterator_impl","numpy.lib._datasource","numpy.lib._format_impl","numpy.lib._function_base_impl","numpy.lib._histograms_impl","numpy.lib._index_tricks_impl","numpy.lib._iotools","numpy.lib._nanfunctions_impl","numpy.lib._npyio_impl","numpy.lib._polynomial_impl","numpy.lib._scimath_impl","numpy.lib._shape_base_impl","numpy.lib._stride_tricks_impl","numpy.lib._twodim_base_impl","numpy.lib._type_check_impl","numpy.lib._ufunclike_impl","numpy.lib._utils_impl","numpy.lib._version","numpy.lib.array_utils","numpy.lib.format","numpy.lib.introspect","numpy.lib.mixins","numpy.lib.npyio","numpy.lib.scimath","numpy.lib.stride_tricks","builtins","_frozen_importlib","abc","typing"],"hash":"fce066af1868cff6e61a3fe7f32f97dbec970eae","id":"numpy.lib","ignore_all":true,"interface_hash":"705fbcc88c640f9d2d3d9b2c391892f6683c9ec3","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/__init__.pyi","plugin_data":null,"size":1651,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_array_utils_impl.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_array_utils_impl.data.json new file mode 100644 index 0000000000000000000000000000000000000000..2a2d7231c9fd4b978b480c94d4a262d3a1bcc68e --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_array_utils_impl.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.lib._array_utils_impl","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef","module_hidden":true,"module_public":false},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib._array_utils_impl.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._array_utils_impl.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._array_utils_impl.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._array_utils_impl.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._array_utils_impl.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._array_utils_impl.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._array_utils_impl.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"byte_bounds":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._array_utils_impl.byte_bounds","name":"byte_bounds","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"byte_bounds","ret_type":{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"generic":{".class":"SymbolTableNode","cross_ref":"numpy.generic","kind":"Gdef","module_hidden":true,"module_public":false},"normalize_axis_index":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1,1,1],"arg_names":["axis","ndim","msg_prefix"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._array_utils_impl.normalize_axis_index","name":"normalize_axis_index","original_first_arg":"axis","type":{".class":"CallableType","arg_kinds":[1,1,1],"arg_names":["axis","ndim","msg_prefix"],"arg_types":["builtins.int","builtins.int",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"normalize_axis_index","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"normalize_axis_tuple":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["axis","ndim","argname","allow_duplicate"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._array_utils_impl.normalize_axis_tuple","name":"normalize_axis_tuple","original_first_arg":"axis","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["axis","ndim","argname","allow_duplicate"],"arg_types":[{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"}],"uses_pep604_syntax":true},"builtins.int",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"normalize_axis_tuple","ret_type":{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_array_utils_impl.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_array_utils_impl.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_array_utils_impl.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..5e00ba316eb82ef6228faae092746dd8022e91ce --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_array_utils_impl.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,5,2,4,1,1,1],"dep_prios":[5,5,5,5,5,30,30],"dependencies":["collections.abc","numpy.typing","typing","numpy","builtins","_frozen_importlib","abc"],"hash":"6ce9e9d1efa2d0d21760b33cd3032ad88b807e02","id":"numpy.lib._array_utils_impl","ignore_all":true,"interface_hash":"e17c86f3d32edf83acab01b50ae9fe48bbf3b6ce","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_array_utils_impl.pyi","plugin_data":null,"size":820,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_arraypad_impl.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_arraypad_impl.data.json new file mode 100644 index 0000000000000000000000000000000000000000..cc770e06603c29e8dab30731ae7fe66a6851f2f1 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_arraypad_impl.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.lib._arraypad_impl","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"L":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"Protocol":{".class":"SymbolTableNode","cross_ref":"typing.Protocol","kind":"Gdef","module_hidden":true,"module_public":false},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.lib._arraypad_impl.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._arraypad_impl.TypeAlias","source_any":null,"type_of_any":3}}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeInt":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeInt","kind":"Gdef","module_hidden":true,"module_public":false},"_ModeFunc":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.lib._arraypad_impl._ModeFunc","name":"_ModeFunc","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy.lib._arraypad_impl._ModeFunc","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.lib._arraypad_impl","mro":["numpy.lib._arraypad_impl._ModeFunc","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0],"arg_names":[null,null,null,null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._arraypad_impl._ModeFunc.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":[null,null,null,null,null],"arg_types":["numpy.lib._arraypad_impl._ModeFunc",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"builtins.int",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ModeFunc","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraypad_impl._ModeFunc.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.lib._arraypad_impl._ModeFunc","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_ModeKind":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.lib._arraypad_impl._ModeKind","name":"_ModeKind","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._arraypad_impl.TypeAlias","source_any":null,"type_of_any":3}}},"_ScalarT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraypad_impl._ScalarT","name":"_ScalarT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib._arraypad_impl.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._arraypad_impl.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._arraypad_impl.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._arraypad_impl.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._arraypad_impl.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._arraypad_impl.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._arraypad_impl.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"generic":{".class":"SymbolTableNode","cross_ref":"numpy.generic","kind":"Gdef","module_hidden":true,"module_public":false},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false},"pad":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._arraypad_impl.pad","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,5,5,5,5],"arg_names":["array","pad_width","mode","stat_length","constant_values","end_values","reflect_type"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraypad_impl.pad","name":"pad","original_first_arg":"array","type":{".class":"CallableType","arg_kinds":[0,0,1,5,5,5,5],"arg_names":["array","pad_width","mode","stat_length","constant_values","end_values","reflect_type"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraypad_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"odd"},{".class":"LiteralType","fallback":"builtins.str","value":"even"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pad","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraypad_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraypad_impl.pad#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraypad_impl.pad","name":"pad","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,5,5,5,5],"arg_names":["array","pad_width","mode","stat_length","constant_values","end_values","reflect_type"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraypad_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"odd"},{".class":"LiteralType","fallback":"builtins.str","value":"even"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pad","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraypad_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraypad_impl.pad#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,5,5,5,5],"arg_names":["array","pad_width","mode","stat_length","constant_values","end_values","reflect_type"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraypad_impl.pad","name":"pad","original_first_arg":"array","type":{".class":"CallableType","arg_kinds":[0,0,1,5,5,5,5],"arg_names":["array","pad_width","mode","stat_length","constant_values","end_values","reflect_type"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraypad_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"odd"},{".class":"LiteralType","fallback":"builtins.str","value":"even"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pad","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraypad_impl.pad","name":"pad","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,5,5,5,5],"arg_names":["array","pad_width","mode","stat_length","constant_values","end_values","reflect_type"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraypad_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"odd"},{".class":"LiteralType","fallback":"builtins.str","value":"even"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pad","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,4],"arg_names":["array","pad_width","mode","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraypad_impl.pad","name":"pad","original_first_arg":"array","type":{".class":"CallableType","arg_kinds":[0,0,0,4],"arg_names":["array","pad_width","mode","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy.lib._arraypad_impl._ModeFunc",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pad","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraypad_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraypad_impl.pad#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraypad_impl.pad","name":"pad","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,4],"arg_names":["array","pad_width","mode","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy.lib._arraypad_impl._ModeFunc",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pad","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraypad_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraypad_impl.pad#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,4],"arg_names":["array","pad_width","mode","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraypad_impl.pad","name":"pad","original_first_arg":"array","type":{".class":"CallableType","arg_kinds":[0,0,0,4],"arg_names":["array","pad_width","mode","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy.lib._arraypad_impl._ModeFunc",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pad","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraypad_impl.pad","name":"pad","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,4],"arg_names":["array","pad_width","mode","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy.lib._arraypad_impl._ModeFunc",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pad","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,5,5,5,5],"arg_names":["array","pad_width","mode","stat_length","constant_values","end_values","reflect_type"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraypad_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"odd"},{".class":"LiteralType","fallback":"builtins.str","value":"even"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pad","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraypad_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraypad_impl.pad#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,5,5,5,5],"arg_names":["array","pad_width","mode","stat_length","constant_values","end_values","reflect_type"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraypad_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"odd"},{".class":"LiteralType","fallback":"builtins.str","value":"even"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pad","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,4],"arg_names":["array","pad_width","mode","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy.lib._arraypad_impl._ModeFunc",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pad","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraypad_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraypad_impl.pad#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,4],"arg_names":["array","pad_width","mode","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy.lib._arraypad_impl._ModeFunc",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pad","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"type_check_only":{".class":"SymbolTableNode","cross_ref":"typing.type_check_only","kind":"Gdef","module_hidden":true,"module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_arraypad_impl.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_arraypad_impl.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_arraypad_impl.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..495b40defa5eb36f1a6cd007d071ed0c49d1090e --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_arraypad_impl.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[14,1,13,1,1,1],"dep_prios":[5,5,5,5,30,30],"dependencies":["numpy._typing","typing","numpy","builtins","_frozen_importlib","abc"],"hash":"04e229e6df7e64ce364d463a9e365d46390b6c44","id":"numpy.lib._arraypad_impl","ignore_all":true,"interface_hash":"3d8bbbf53fe5fa3d53e29b85058543b82de722aa","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_arraypad_impl.pyi","plugin_data":null,"size":1837,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_arraysetops_impl.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_arraysetops_impl.data.json new file mode 100644 index 0000000000000000000000000000000000000000..2082f504faac74d9d084b31d91dde90f7c8c2616 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_arraysetops_impl.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.lib._arraysetops_impl","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"Generic":{".class":"SymbolTableNode","cross_ref":"typing.Generic","kind":"Gdef","module_hidden":true,"module_public":false},"L":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"NamedTuple":{".class":"SymbolTableNode","cross_ref":"typing.NamedTuple","kind":"Gdef","module_hidden":true,"module_public":false},"SupportsIndex":{".class":"SymbolTableNode","cross_ref":"typing.SupportsIndex","kind":"Gdef","module_hidden":true,"module_public":false},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing_extensions.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"UniqueAllResult":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.lib._arraysetops_impl.UniqueAllResult","name":"UniqueAllResult","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.UniqueAllResult","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},"deletable_attributes":[],"deprecated":null,"flags":["is_named_tuple"],"fullname":"numpy.lib._arraysetops_impl.UniqueAllResult","has_param_spec_type":false,"metaclass_type":null,"metadata":{"namedtuple":{"fields":["values","indices","inverse_indices","counts"]}},"module_name":"numpy.lib._arraysetops_impl","mro":["numpy.lib._arraysetops_impl.UniqueAllResult","builtins.tuple","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","_NT":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueAllResult._NT","name":"_NT","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},"__annotations__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._arraysetops_impl.UniqueAllResult.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._arraysetops_impl.UniqueAllResult.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__new__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0],"arg_names":["_cls","values","indices","inverse_indices","counts"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static"],"fullname":"numpy.lib._arraysetops_impl.UniqueAllResult.__new__","name":"__new__","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":["_cls","values","indices","inverse_indices","counts"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueAllResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueAllResult.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of UniqueAllResult","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueAllResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueAllResult.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueAllResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueAllResult.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_asdict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["_self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._arraysetops_impl.UniqueAllResult._asdict","name":"_asdict","original_first_arg":"_self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["_self"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueAllResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueAllResult._asdict","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_asdict of UniqueAllResult","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueAllResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueAllResult._asdict","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_field_defaults":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._arraysetops_impl.UniqueAllResult._field_defaults","name":"_field_defaults","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_field_types":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._arraysetops_impl.UniqueAllResult._field_types","name":"_field_types","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_fields":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._arraysetops_impl.UniqueAllResult._fields","name":"_fields","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_make":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["_cls","iterable"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.UniqueAllResult._make","name":"_make","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["_cls","iterable"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueAllResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueAllResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_make of UniqueAllResult","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueAllResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueAllResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueAllResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueAllResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_classmethod","is_ready"],"fullname":"numpy.lib._arraysetops_impl.UniqueAllResult._make","name":"_make","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["_cls","iterable"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueAllResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueAllResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_make of UniqueAllResult","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueAllResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueAllResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueAllResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueAllResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}}},"plugin_generated":true},"_replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5],"arg_names":["_self","values","indices","inverse_indices","counts"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._arraysetops_impl.UniqueAllResult._replace","name":"_replace","original_first_arg":"_self","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":["_self","values","indices","inverse_indices","counts"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueAllResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueAllResult._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_replace of UniqueAllResult","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueAllResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueAllResult._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueAllResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueAllResult._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_source":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._arraysetops_impl.UniqueAllResult._source","name":"_source","setter_type":null,"type":"builtins.str"}},"counts":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"numpy.lib._arraysetops_impl.UniqueAllResult.counts","name":"counts","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}}},"counts-redefinition":{".class":"SymbolTableNode","cross_ref":"numpy.lib._arraysetops_impl.UniqueAllResult.counts","kind":"Mdef"},"indices":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"numpy.lib._arraysetops_impl.UniqueAllResult.indices","name":"indices","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}}},"indices-redefinition":{".class":"SymbolTableNode","cross_ref":"numpy.lib._arraysetops_impl.UniqueAllResult.indices","kind":"Mdef"},"inverse_indices":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"numpy.lib._arraysetops_impl.UniqueAllResult.inverse_indices","name":"inverse_indices","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}}},"inverse_indices-redefinition":{".class":"SymbolTableNode","cross_ref":"numpy.lib._arraysetops_impl.UniqueAllResult.inverse_indices","kind":"Mdef"},"values":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"numpy.lib._arraysetops_impl.UniqueAllResult.values","name":"values","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"values-redefinition":{".class":"SymbolTableNode","cross_ref":"numpy.lib._arraysetops_impl.UniqueAllResult.values","kind":"Mdef"}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueAllResult.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.UniqueAllResult","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.lib._arraysetops_impl.UniqueAllResult"}},"values":[],"variance":0},"slots":null,"tuple_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_vars":["_ScalarT"],"typeddict_type":null}},"UniqueCountsResult":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.lib._arraysetops_impl.UniqueCountsResult","name":"UniqueCountsResult","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.UniqueCountsResult","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},"deletable_attributes":[],"deprecated":null,"flags":["is_named_tuple"],"fullname":"numpy.lib._arraysetops_impl.UniqueCountsResult","has_param_spec_type":false,"metaclass_type":null,"metadata":{"namedtuple":{"fields":["values","counts"]}},"module_name":"numpy.lib._arraysetops_impl","mro":["numpy.lib._arraysetops_impl.UniqueCountsResult","builtins.tuple","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","_NT":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueCountsResult._NT","name":"_NT","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},"__annotations__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._arraysetops_impl.UniqueCountsResult.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._arraysetops_impl.UniqueCountsResult.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__new__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["_cls","values","counts"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static"],"fullname":"numpy.lib._arraysetops_impl.UniqueCountsResult.__new__","name":"__new__","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["_cls","values","counts"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueCountsResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueCountsResult.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of UniqueCountsResult","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueCountsResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueCountsResult.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueCountsResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueCountsResult.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_asdict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["_self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._arraysetops_impl.UniqueCountsResult._asdict","name":"_asdict","original_first_arg":"_self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["_self"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueCountsResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueCountsResult._asdict","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_asdict of UniqueCountsResult","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueCountsResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueCountsResult._asdict","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_field_defaults":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._arraysetops_impl.UniqueCountsResult._field_defaults","name":"_field_defaults","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_field_types":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._arraysetops_impl.UniqueCountsResult._field_types","name":"_field_types","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_fields":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._arraysetops_impl.UniqueCountsResult._fields","name":"_fields","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_make":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["_cls","iterable"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.UniqueCountsResult._make","name":"_make","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["_cls","iterable"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueCountsResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueCountsResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_make of UniqueCountsResult","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueCountsResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueCountsResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueCountsResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueCountsResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_classmethod","is_ready"],"fullname":"numpy.lib._arraysetops_impl.UniqueCountsResult._make","name":"_make","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["_cls","iterable"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueCountsResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueCountsResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_make of UniqueCountsResult","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueCountsResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueCountsResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueCountsResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueCountsResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}}},"plugin_generated":true},"_replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5],"arg_names":["_self","values","counts"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._arraysetops_impl.UniqueCountsResult._replace","name":"_replace","original_first_arg":"_self","type":{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":["_self","values","counts"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueCountsResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueCountsResult._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_replace of UniqueCountsResult","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueCountsResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueCountsResult._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueCountsResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueCountsResult._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_source":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._arraysetops_impl.UniqueCountsResult._source","name":"_source","setter_type":null,"type":"builtins.str"}},"counts":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"numpy.lib._arraysetops_impl.UniqueCountsResult.counts","name":"counts","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}}},"counts-redefinition":{".class":"SymbolTableNode","cross_ref":"numpy.lib._arraysetops_impl.UniqueCountsResult.counts","kind":"Mdef"},"values":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"numpy.lib._arraysetops_impl.UniqueCountsResult.values","name":"values","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"values-redefinition":{".class":"SymbolTableNode","cross_ref":"numpy.lib._arraysetops_impl.UniqueCountsResult.values","kind":"Mdef"}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueCountsResult.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.UniqueCountsResult","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.lib._arraysetops_impl.UniqueCountsResult"}},"values":[],"variance":0},"slots":null,"tuple_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_vars":["_ScalarT"],"typeddict_type":null}},"UniqueInverseResult":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.lib._arraysetops_impl.UniqueInverseResult","name":"UniqueInverseResult","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.UniqueInverseResult","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},"deletable_attributes":[],"deprecated":null,"flags":["is_named_tuple"],"fullname":"numpy.lib._arraysetops_impl.UniqueInverseResult","has_param_spec_type":false,"metaclass_type":null,"metadata":{"namedtuple":{"fields":["values","inverse_indices"]}},"module_name":"numpy.lib._arraysetops_impl","mro":["numpy.lib._arraysetops_impl.UniqueInverseResult","builtins.tuple","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","_NT":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueInverseResult._NT","name":"_NT","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},"__annotations__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._arraysetops_impl.UniqueInverseResult.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._arraysetops_impl.UniqueInverseResult.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__new__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["_cls","values","inverse_indices"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static"],"fullname":"numpy.lib._arraysetops_impl.UniqueInverseResult.__new__","name":"__new__","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["_cls","values","inverse_indices"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueInverseResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueInverseResult.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of UniqueInverseResult","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueInverseResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueInverseResult.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueInverseResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueInverseResult.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_asdict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["_self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._arraysetops_impl.UniqueInverseResult._asdict","name":"_asdict","original_first_arg":"_self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["_self"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueInverseResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueInverseResult._asdict","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_asdict of UniqueInverseResult","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueInverseResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueInverseResult._asdict","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_field_defaults":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._arraysetops_impl.UniqueInverseResult._field_defaults","name":"_field_defaults","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_field_types":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._arraysetops_impl.UniqueInverseResult._field_types","name":"_field_types","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_fields":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._arraysetops_impl.UniqueInverseResult._fields","name":"_fields","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_make":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["_cls","iterable"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.UniqueInverseResult._make","name":"_make","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["_cls","iterable"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueInverseResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueInverseResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_make of UniqueInverseResult","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueInverseResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueInverseResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueInverseResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueInverseResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_classmethod","is_ready"],"fullname":"numpy.lib._arraysetops_impl.UniqueInverseResult._make","name":"_make","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["_cls","iterable"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueInverseResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueInverseResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_make of UniqueInverseResult","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueInverseResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueInverseResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueInverseResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueInverseResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}}},"plugin_generated":true},"_replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5],"arg_names":["_self","values","inverse_indices"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._arraysetops_impl.UniqueInverseResult._replace","name":"_replace","original_first_arg":"_self","type":{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":["_self","values","inverse_indices"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueInverseResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueInverseResult._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_replace of UniqueInverseResult","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueInverseResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueInverseResult._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueInverseResult._NT","id":-1,"name":"_NT","namespace":"numpy.lib._arraysetops_impl.UniqueInverseResult._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_source":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._arraysetops_impl.UniqueInverseResult._source","name":"_source","setter_type":null,"type":"builtins.str"}},"inverse_indices":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"numpy.lib._arraysetops_impl.UniqueInverseResult.inverse_indices","name":"inverse_indices","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}}},"inverse_indices-redefinition":{".class":"SymbolTableNode","cross_ref":"numpy.lib._arraysetops_impl.UniqueInverseResult.inverse_indices","kind":"Mdef"},"values":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"numpy.lib._arraysetops_impl.UniqueInverseResult.values","name":"values","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"values-redefinition":{".class":"SymbolTableNode","cross_ref":"numpy.lib._arraysetops_impl.UniqueInverseResult.values","kind":"Mdef"}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl.UniqueInverseResult.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.UniqueInverseResult","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.lib._arraysetops_impl.UniqueInverseResult"}},"values":[],"variance":0},"slots":null,"tuple_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_vars":["_ScalarT"],"typeddict_type":null}},"_AnyArray":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.lib._arraysetops_impl._AnyArray","name":"_AnyArray","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}}},"_ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeBool_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeBool_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeNumber_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeNumber_co","kind":"Gdef","module_hidden":true,"module_public":false},"_EitherSCT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._EitherSCT","name":"_EitherSCT","upper_bound":"builtins.object","values":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.float64",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.complex128",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"numpy.bytes_","numpy.str_","numpy.void","numpy.object_",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"variance":0}},"_IntArray":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.lib._arraysetops_impl._IntArray","name":"_IntArray","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}}},"_NumericT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._NumericT","name":"_NumericT","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0}},"_ScalarT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","name":"_ScalarT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib._arraysetops_impl.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._arraysetops_impl.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._arraysetops_impl.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._arraysetops_impl.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._arraysetops_impl.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._arraysetops_impl.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._arraysetops_impl.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"deprecated":{".class":"SymbolTableNode","cross_ref":"typing_extensions.deprecated","kind":"Gdef","module_hidden":true,"module_public":false},"ediff1d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._arraysetops_impl.ediff1d","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["ary","to_end","to_begin"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.ediff1d","name":"ediff1d","original_first_arg":"ary","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["ary","to_end","to_begin"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ediff1d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.ediff1d","name":"ediff1d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["ary","to_end","to_begin"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ediff1d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["ary","to_end","to_begin"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.ediff1d","name":"ediff1d","original_first_arg":"ary","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["ary","to_end","to_begin"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ediff1d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._NumericT","id":-1,"name":"_NumericT","namespace":"numpy.lib._arraysetops_impl.ediff1d#1","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.ediff1d","name":"ediff1d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["ary","to_end","to_begin"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ediff1d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._NumericT","id":-1,"name":"_NumericT","namespace":"numpy.lib._arraysetops_impl.ediff1d#1","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["ary","to_end","to_begin"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.ediff1d","name":"ediff1d","original_first_arg":"ary","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["ary","to_end","to_begin"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ediff1d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.ediff1d","name":"ediff1d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["ary","to_end","to_begin"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ediff1d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["ary","to_end","to_begin"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.ediff1d","name":"ediff1d","original_first_arg":"ary","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["ary","to_end","to_begin"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ediff1d","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.ediff1d","name":"ediff1d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["ary","to_end","to_begin"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ediff1d","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["ary","to_end","to_begin"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ediff1d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["ary","to_end","to_begin"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ediff1d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._NumericT","id":-1,"name":"_NumericT","namespace":"numpy.lib._arraysetops_impl.ediff1d#1","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["ary","to_end","to_begin"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ediff1d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["ary","to_end","to_begin"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ediff1d","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"in1d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,5],"arg_names":["element","test_elements","assume_unique","invert","kind"],"dataclass_transform_spec":null,"deprecated":"function numpy.lib._arraysetops_impl.in1d is deprecated: Use 'isin' instead","flags":["is_decorated"],"fullname":"numpy.lib._arraysetops_impl.in1d","name":"in1d","original_first_arg":"element","type":{".class":"CallableType","arg_kinds":[0,0,1,1,5],"arg_names":["element","test_elements","assume_unique","invert","kind"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.bool",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"sort"},{".class":"LiteralType","fallback":"builtins.str","value":"table"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"in1d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.in1d","name":"in1d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,5],"arg_names":["element","test_elements","assume_unique","invert","kind"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.bool",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"sort"},{".class":"LiteralType","fallback":"builtins.str","value":"table"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"in1d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"intersect1d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._arraysetops_impl.intersect1d","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["ar1","ar2","assume_unique","return_indices"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.intersect1d","name":"intersect1d","original_first_arg":"ar1","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["ar1","ar2","assume_unique","return_indices"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"intersect1d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._EitherSCT","id":-1,"name":"_EitherSCT","namespace":"numpy.lib._arraysetops_impl.intersect1d#0","upper_bound":"builtins.object","values":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.float64",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.complex128",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"numpy.bytes_","numpy.str_","numpy.void","numpy.object_",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.intersect1d","name":"intersect1d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["ar1","ar2","assume_unique","return_indices"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"intersect1d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._EitherSCT","id":-1,"name":"_EitherSCT","namespace":"numpy.lib._arraysetops_impl.intersect1d#0","upper_bound":"builtins.object","values":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.float64",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.complex128",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"numpy.bytes_","numpy.str_","numpy.void","numpy.object_",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["ar1","ar2","assume_unique","return_indices"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.intersect1d","name":"intersect1d","original_first_arg":"ar1","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["ar1","ar2","assume_unique","return_indices"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"intersect1d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._EitherSCT","id":-1,"name":"_EitherSCT","namespace":"numpy.lib._arraysetops_impl.intersect1d#1","upper_bound":"builtins.object","values":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.float64",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.complex128",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"numpy.bytes_","numpy.str_","numpy.void","numpy.object_",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.intersect1d","name":"intersect1d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["ar1","ar2","assume_unique","return_indices"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"intersect1d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._EitherSCT","id":-1,"name":"_EitherSCT","namespace":"numpy.lib._arraysetops_impl.intersect1d#1","upper_bound":"builtins.object","values":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.float64",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.complex128",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"numpy.bytes_","numpy.str_","numpy.void","numpy.object_",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,3],"arg_names":["ar1","ar2","assume_unique","return_indices"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.intersect1d","name":"intersect1d","original_first_arg":"ar1","type":{".class":"CallableType","arg_kinds":[0,0,1,3],"arg_names":["ar1","ar2","assume_unique","return_indices"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"intersect1d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._EitherSCT","id":-1,"name":"_EitherSCT","namespace":"numpy.lib._arraysetops_impl.intersect1d#2","upper_bound":"builtins.object","values":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.float64",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.complex128",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"numpy.bytes_","numpy.str_","numpy.void","numpy.object_",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.intersect1d","name":"intersect1d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,3],"arg_names":["ar1","ar2","assume_unique","return_indices"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"intersect1d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._EitherSCT","id":-1,"name":"_EitherSCT","namespace":"numpy.lib._arraysetops_impl.intersect1d#2","upper_bound":"builtins.object","values":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.float64",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.complex128",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"numpy.bytes_","numpy.str_","numpy.void","numpy.object_",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["ar1","ar2","assume_unique","return_indices"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.intersect1d","name":"intersect1d","original_first_arg":"ar1","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["ar1","ar2","assume_unique","return_indices"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"intersect1d","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.intersect1d","name":"intersect1d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["ar1","ar2","assume_unique","return_indices"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"intersect1d","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["ar1","ar2","assume_unique","return_indices"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.intersect1d","name":"intersect1d","original_first_arg":"ar1","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["ar1","ar2","assume_unique","return_indices"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"intersect1d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.intersect1d","name":"intersect1d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["ar1","ar2","assume_unique","return_indices"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"intersect1d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,3],"arg_names":["ar1","ar2","assume_unique","return_indices"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.intersect1d","name":"intersect1d","original_first_arg":"ar1","type":{".class":"CallableType","arg_kinds":[0,0,1,3],"arg_names":["ar1","ar2","assume_unique","return_indices"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"intersect1d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.intersect1d","name":"intersect1d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,3],"arg_names":["ar1","ar2","assume_unique","return_indices"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"intersect1d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["ar1","ar2","assume_unique","return_indices"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"intersect1d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._EitherSCT","id":-1,"name":"_EitherSCT","namespace":"numpy.lib._arraysetops_impl.intersect1d#0","upper_bound":"builtins.object","values":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.float64",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.complex128",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"numpy.bytes_","numpy.str_","numpy.void","numpy.object_",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["ar1","ar2","assume_unique","return_indices"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"intersect1d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._EitherSCT","id":-1,"name":"_EitherSCT","namespace":"numpy.lib._arraysetops_impl.intersect1d#1","upper_bound":"builtins.object","values":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.float64",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.complex128",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"numpy.bytes_","numpy.str_","numpy.void","numpy.object_",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,3],"arg_names":["ar1","ar2","assume_unique","return_indices"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"intersect1d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._EitherSCT","id":-1,"name":"_EitherSCT","namespace":"numpy.lib._arraysetops_impl.intersect1d#2","upper_bound":"builtins.object","values":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.float64",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.complex128",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"numpy.bytes_","numpy.str_","numpy.void","numpy.object_",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["ar1","ar2","assume_unique","return_indices"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"intersect1d","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["ar1","ar2","assume_unique","return_indices"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"intersect1d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,3],"arg_names":["ar1","ar2","assume_unique","return_indices"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"intersect1d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"isin":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,5],"arg_names":["element","test_elements","assume_unique","invert","kind"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._arraysetops_impl.isin","name":"isin","original_first_arg":"element","type":{".class":"CallableType","arg_kinds":[0,0,1,1,5],"arg_names":["element","test_elements","assume_unique","invert","kind"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.bool",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"sort"},{".class":"LiteralType","fallback":"builtins.str","value":"table"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isin","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false},"setdiff1d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._arraysetops_impl.setdiff1d","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["ar1","ar2","assume_unique"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.setdiff1d","name":"setdiff1d","original_first_arg":"ar1","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["ar1","ar2","assume_unique"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"setdiff1d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._EitherSCT","id":-1,"name":"_EitherSCT","namespace":"numpy.lib._arraysetops_impl.setdiff1d#0","upper_bound":"builtins.object","values":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.float64",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.complex128",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"numpy.bytes_","numpy.str_","numpy.void","numpy.object_",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.setdiff1d","name":"setdiff1d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["ar1","ar2","assume_unique"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"setdiff1d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._EitherSCT","id":-1,"name":"_EitherSCT","namespace":"numpy.lib._arraysetops_impl.setdiff1d#0","upper_bound":"builtins.object","values":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.float64",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.complex128",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"numpy.bytes_","numpy.str_","numpy.void","numpy.object_",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["ar1","ar2","assume_unique"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.setdiff1d","name":"setdiff1d","original_first_arg":"ar1","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["ar1","ar2","assume_unique"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"setdiff1d","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.setdiff1d","name":"setdiff1d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["ar1","ar2","assume_unique"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"setdiff1d","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["ar1","ar2","assume_unique"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"setdiff1d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._EitherSCT","id":-1,"name":"_EitherSCT","namespace":"numpy.lib._arraysetops_impl.setdiff1d#0","upper_bound":"builtins.object","values":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.float64",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.complex128",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"numpy.bytes_","numpy.str_","numpy.void","numpy.object_",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["ar1","ar2","assume_unique"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"setdiff1d","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"setxor1d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._arraysetops_impl.setxor1d","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["ar1","ar2","assume_unique"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.setxor1d","name":"setxor1d","original_first_arg":"ar1","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["ar1","ar2","assume_unique"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"setxor1d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._EitherSCT","id":-1,"name":"_EitherSCT","namespace":"numpy.lib._arraysetops_impl.setxor1d#0","upper_bound":"builtins.object","values":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.float64",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.complex128",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"numpy.bytes_","numpy.str_","numpy.void","numpy.object_",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.setxor1d","name":"setxor1d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["ar1","ar2","assume_unique"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"setxor1d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._EitherSCT","id":-1,"name":"_EitherSCT","namespace":"numpy.lib._arraysetops_impl.setxor1d#0","upper_bound":"builtins.object","values":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.float64",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.complex128",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"numpy.bytes_","numpy.str_","numpy.void","numpy.object_",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["ar1","ar2","assume_unique"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.setxor1d","name":"setxor1d","original_first_arg":"ar1","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["ar1","ar2","assume_unique"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"setxor1d","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.setxor1d","name":"setxor1d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["ar1","ar2","assume_unique"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"setxor1d","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["ar1","ar2","assume_unique"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"setxor1d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._EitherSCT","id":-1,"name":"_EitherSCT","namespace":"numpy.lib._arraysetops_impl.setxor1d#0","upper_bound":"builtins.object","values":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.float64",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.complex128",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"numpy.bytes_","numpy.str_","numpy.void","numpy.object_",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["ar1","ar2","assume_unique"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"setxor1d","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"union1d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._arraysetops_impl.union1d","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["ar1","ar2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.union1d","name":"union1d","original_first_arg":"ar1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["ar1","ar2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"union1d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._EitherSCT","id":-1,"name":"_EitherSCT","namespace":"numpy.lib._arraysetops_impl.union1d#0","upper_bound":"builtins.object","values":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.float64",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.complex128",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"numpy.bytes_","numpy.str_","numpy.void","numpy.object_",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.union1d","name":"union1d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["ar1","ar2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"union1d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._EitherSCT","id":-1,"name":"_EitherSCT","namespace":"numpy.lib._arraysetops_impl.union1d#0","upper_bound":"builtins.object","values":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.float64",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.complex128",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"numpy.bytes_","numpy.str_","numpy.void","numpy.object_",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["ar1","ar2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.union1d","name":"union1d","original_first_arg":"ar1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["ar1","ar2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"union1d","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.union1d","name":"union1d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["ar1","ar2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"union1d","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["ar1","ar2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"union1d","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._EitherSCT","id":-1,"name":"_EitherSCT","namespace":"numpy.lib._arraysetops_impl.union1d#0","upper_bound":"builtins.object","values":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.float64",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"numpy.complex128",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"numpy.bytes_","numpy.str_","numpy.void","numpy.object_",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["ar1","ar2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"union1d","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"unique":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._arraysetops_impl.unique","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","original_first_arg":"ar","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","original_first_arg":"ar","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","original_first_arg":"ar","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","original_first_arg":"ar","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","original_first_arg":"ar","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3,5,5,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","original_first_arg":"ar","type":{".class":"CallableType","arg_kinds":[0,1,3,5,5,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3,5,5,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","original_first_arg":"ar","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3,5,5,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","original_first_arg":"ar","type":{".class":"CallableType","arg_kinds":[0,1,3,5,5,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3,5,5,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","original_first_arg":"ar","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique#8","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique#8","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,3,5,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","original_first_arg":"ar","type":{".class":"CallableType","arg_kinds":[0,1,1,3,5,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,3,5,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","original_first_arg":"ar","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,3,5,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","original_first_arg":"ar","type":{".class":"CallableType","arg_kinds":[0,1,1,3,5,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,3,5,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","original_first_arg":"ar","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique#12","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique#12","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","original_first_arg":"ar","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","original_first_arg":"ar","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique#14","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique#14","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,3,5,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","original_first_arg":"ar","type":{".class":"CallableType","arg_kinds":[0,0,1,3,5,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique#15","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,3,5,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique#15","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","original_first_arg":"ar","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,3,5,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","original_first_arg":"ar","type":{".class":"CallableType","arg_kinds":[0,0,1,3,5,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,3,5,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","original_first_arg":"ar","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique#18","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique#18","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3,3,5,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","original_first_arg":"ar","type":{".class":"CallableType","arg_kinds":[0,1,3,3,5,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique#19","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3,3,5,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique#19","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","original_first_arg":"ar","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3,3,5,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","original_first_arg":"ar","type":{".class":"CallableType","arg_kinds":[0,1,3,3,5,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3,3,5,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","original_first_arg":"ar","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique#22","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique#22","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","original_first_arg":"ar","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.unique","name":"unique","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5,5,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,3,5,5,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique#8","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,3,5,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,0,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,3,5,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique#12","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique#14","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,3,5,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique#15","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,0,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,3,5,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique#18","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,3,5,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique#19","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,0,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,3,3,5,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique#22","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,0,1,5,5],"arg_names":["ar","return_index","return_inverse","return_counts","axis","equal_nan","sorted"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"unique_all":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._arraysetops_impl.unique_all","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.unique_all","name":"unique_all","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique_all","ret_type":{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique_all#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"type_ref":"numpy.lib._arraysetops_impl.UniqueAllResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique_all#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.unique_all","name":"unique_all","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique_all","ret_type":{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique_all#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"type_ref":"numpy.lib._arraysetops_impl.UniqueAllResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique_all#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.unique_all","name":"unique_all","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique_all","ret_type":{".class":"TypeAliasType","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"type_ref":"numpy.lib._arraysetops_impl.UniqueAllResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.unique_all","name":"unique_all","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique_all","ret_type":{".class":"TypeAliasType","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"type_ref":"numpy.lib._arraysetops_impl.UniqueAllResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique_all","ret_type":{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique_all#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"type_ref":"numpy.lib._arraysetops_impl.UniqueAllResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique_all#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique_all","ret_type":{".class":"TypeAliasType","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"type_ref":"numpy.lib._arraysetops_impl.UniqueAllResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"unique_counts":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._arraysetops_impl.unique_counts","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.unique_counts","name":"unique_counts","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique_counts","ret_type":{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique_counts#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"type_ref":"numpy.lib._arraysetops_impl.UniqueCountsResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique_counts#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.unique_counts","name":"unique_counts","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique_counts","ret_type":{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique_counts#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"type_ref":"numpy.lib._arraysetops_impl.UniqueCountsResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique_counts#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.unique_counts","name":"unique_counts","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique_counts","ret_type":{".class":"TypeAliasType","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"type_ref":"numpy.lib._arraysetops_impl.UniqueCountsResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.unique_counts","name":"unique_counts","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique_counts","ret_type":{".class":"TypeAliasType","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"type_ref":"numpy.lib._arraysetops_impl.UniqueCountsResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique_counts","ret_type":{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique_counts#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"type_ref":"numpy.lib._arraysetops_impl.UniqueCountsResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique_counts#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique_counts","ret_type":{".class":"TypeAliasType","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"type_ref":"numpy.lib._arraysetops_impl.UniqueCountsResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"unique_inverse":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._arraysetops_impl.unique_inverse","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.unique_inverse","name":"unique_inverse","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique_inverse","ret_type":{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique_inverse#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"type_ref":"numpy.lib._arraysetops_impl.UniqueInverseResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique_inverse#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.unique_inverse","name":"unique_inverse","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique_inverse","ret_type":{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique_inverse#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"type_ref":"numpy.lib._arraysetops_impl.UniqueInverseResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique_inverse#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.unique_inverse","name":"unique_inverse","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique_inverse","ret_type":{".class":"TypeAliasType","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"type_ref":"numpy.lib._arraysetops_impl.UniqueInverseResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.unique_inverse","name":"unique_inverse","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique_inverse","ret_type":{".class":"TypeAliasType","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"type_ref":"numpy.lib._arraysetops_impl.UniqueInverseResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique_inverse","ret_type":{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique_inverse#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"type_ref":"numpy.lib._arraysetops_impl.UniqueInverseResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique_inverse#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique_inverse","ret_type":{".class":"TypeAliasType","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"type_ref":"numpy.lib._arraysetops_impl.UniqueInverseResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"unique_values":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._arraysetops_impl.unique_values","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.unique_values","name":"unique_values","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique_values","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique_values#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.unique_values","name":"unique_values","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique_values","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique_values#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._arraysetops_impl.unique_values","name":"unique_values","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique_values","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arraysetops_impl.unique_values","name":"unique_values","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique_values","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique_values","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arraysetops_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arraysetops_impl.unique_values#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique_values","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._arraysetops_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_arraysetops_impl.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_arraysetops_impl.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_arraysetops_impl.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..2df96a0b111058e428532a637c226755e131f1fb --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_arraysetops_impl.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[7,1,4,6,1,1,1,1],"dep_prios":[5,5,5,10,5,30,30,30],"dependencies":["numpy._typing","typing","typing_extensions","numpy","builtins","_frozen_importlib","abc","numpy._typing._array_like"],"hash":"fbe76582ee999c21843ee63044112edc2bec252e","id":"numpy.lib._arraysetops_impl","ignore_all":true,"interface_hash":"b4af15dc7918232fd885c40c89c75af5b8f25846","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_arraysetops_impl.pyi","plugin_data":null,"size":13403,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_arrayterator_impl.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_arrayterator_impl.data.json new file mode 100644 index 0000000000000000000000000000000000000000..9d586684ca5dfaaae3bedc1bcde77ccb7f1a9173 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_arrayterator_impl.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.lib._arrayterator_impl","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"Arrayterator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.lib._arrayterator_impl._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.lib._arrayterator_impl._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ndarray"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.lib._arrayterator_impl.Arrayterator","name":"Arrayterator","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.lib._arrayterator_impl._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.lib._arrayterator_impl._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.lib._arrayterator_impl.Arrayterator","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.lib._arrayterator_impl","mro":["numpy.lib._arrayterator_impl.Arrayterator","numpy.ndarray","numpy._ArrayOrScalarCommon","builtins.object"],"names":{".class":"SymbolTable","__array__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._arrayterator_impl.Arrayterator.__array__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":[null,"dtype","copy"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.lib._arrayterator_impl.Arrayterator.__array__","name":"__array__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":[null,"dtype","copy"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.lib._arrayterator_impl._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.lib._arrayterator_impl._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._arrayterator_impl.Arrayterator"},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__array__ of Arrayterator","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.lib._arrayterator_impl._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.lib._arrayterator_impl._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arrayterator_impl.Arrayterator.__array__","name":"__array__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":[null,"dtype","copy"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.lib._arrayterator_impl._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.lib._arrayterator_impl._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._arrayterator_impl.Arrayterator"},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__array__ of Arrayterator","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.lib._arrayterator_impl._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.lib._arrayterator_impl._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":[null,"dtype","copy"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.lib._arrayterator_impl.Arrayterator.__array__","name":"__array__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":[null,"dtype","copy"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.lib._arrayterator_impl._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.lib._arrayterator_impl._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._arrayterator_impl.Arrayterator"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arrayterator_impl._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy.lib._arrayterator_impl.Arrayterator.__array__","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__array__ of Arrayterator","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.lib._arrayterator_impl._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arrayterator_impl._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy.lib._arrayterator_impl.Arrayterator.__array__","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arrayterator_impl._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy.lib._arrayterator_impl.Arrayterator.__array__","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._arrayterator_impl.Arrayterator.__array__","name":"__array__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":[null,"dtype","copy"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.lib._arrayterator_impl._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.lib._arrayterator_impl._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._arrayterator_impl.Arrayterator"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arrayterator_impl._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy.lib._arrayterator_impl.Arrayterator.__array__","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__array__ of Arrayterator","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.lib._arrayterator_impl._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arrayterator_impl._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy.lib._arrayterator_impl.Arrayterator.__array__","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arrayterator_impl._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy.lib._arrayterator_impl.Arrayterator.__array__","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":[null,"dtype","copy"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.lib._arrayterator_impl._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.lib._arrayterator_impl._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._arrayterator_impl.Arrayterator"},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__array__ of Arrayterator","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.lib._arrayterator_impl._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.lib._arrayterator_impl._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":[null,"dtype","copy"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.lib._arrayterator_impl._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.lib._arrayterator_impl._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._arrayterator_impl.Arrayterator"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arrayterator_impl._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy.lib._arrayterator_impl.Arrayterator.__array__","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__array__ of Arrayterator","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.lib._arrayterator_impl._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arrayterator_impl._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy.lib._arrayterator_impl.Arrayterator.__array__","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arrayterator_impl._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy.lib._arrayterator_impl.Arrayterator.__array__","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}]}]}}},"__getitem__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._arrayterator_impl.Arrayterator.__getitem__","name":"__getitem__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.lib._arrayterator_impl._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.lib._arrayterator_impl._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._arrayterator_impl.Arrayterator"},{".class":"AnyType","missing_import_name":"numpy.lib._arrayterator_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of Arrayterator","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.lib._arrayterator_impl._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._arrayterator_impl.Arrayterator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":[null,"var","buf_size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._arrayterator_impl.Arrayterator.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":[null,"var","buf_size"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.lib._arrayterator_impl._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.lib._arrayterator_impl._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._arrayterator_impl.Arrayterator"},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.lib._arrayterator_impl._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.lib._arrayterator_impl._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ndarray"},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of Arrayterator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__iter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._arrayterator_impl.Arrayterator.__iter__","name":"__iter__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.lib._arrayterator_impl._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.lib._arrayterator_impl._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._arrayterator_impl.Arrayterator"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iter__ of Arrayterator","ret_type":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.lib._arrayterator_impl._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ndarray"},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Generator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"buf_size":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","final_unset_in_class","is_ready"],"fullname":"numpy.lib._arrayterator_impl.Arrayterator.buf_size","name":"buf_size","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"flat":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated"],"fullname":"numpy.lib._arrayterator_impl.Arrayterator.flat","name":"flat","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arrayterator_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arrayterator_impl.Arrayterator.flat","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.lib._arrayterator_impl.Arrayterator"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"flat of Arrayterator","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arrayterator_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arrayterator_impl.Arrayterator.flat","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Generator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arrayterator_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arrayterator_impl.Arrayterator.flat","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy.lib._arrayterator_impl.Arrayterator.flat","name":"flat","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arrayterator_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arrayterator_impl.Arrayterator.flat","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.lib._arrayterator_impl.Arrayterator"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"flat of Arrayterator","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arrayterator_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arrayterator_impl.Arrayterator.flat","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Generator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arrayterator_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._arrayterator_impl.Arrayterator.flat","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}}},"shape":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy.lib._arrayterator_impl.Arrayterator.shape","name":"shape","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.lib._arrayterator_impl._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.lib._arrayterator_impl._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._arrayterator_impl.Arrayterator"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shape of Arrayterator","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.lib._arrayterator_impl._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy.lib._arrayterator_impl.Arrayterator.shape","name":"shape","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.lib._arrayterator_impl._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.lib._arrayterator_impl._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._arrayterator_impl.Arrayterator"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shape of Arrayterator","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.lib._arrayterator_impl._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"start":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","final_unset_in_class","is_ready"],"fullname":"numpy.lib._arrayterator_impl.Arrayterator.start","name":"start","setter_type":null,"type":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.list"}}},"step":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","final_unset_in_class","is_ready"],"fullname":"numpy.lib._arrayterator_impl.Arrayterator.step","name":"step","setter_type":null,"type":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.list"}}},"stop":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","final_unset_in_class","is_ready"],"fullname":"numpy.lib._arrayterator_impl.Arrayterator.stop","name":"stop","setter_type":null,"type":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.list"}}},"var":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._arrayterator_impl.Arrayterator.var","name":"var","setter_type":null,"type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.lib._arrayterator_impl._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.lib._arrayterator_impl._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ndarray"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arrayterator_impl.Arrayterator.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.lib._arrayterator_impl._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.lib._arrayterator_impl._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.lib._arrayterator_impl.Arrayterator","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._arrayterator_impl.Arrayterator"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_ShapeT_co","_DTypeT_co"],"typeddict_type":null}},"EllipsisType":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.lib._arrayterator_impl.EllipsisType","name":"EllipsisType","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._arrayterator_impl.EllipsisType","source_any":null,"type_of_any":3}}},"Final":{".class":"SymbolTableNode","cross_ref":"typing.Final","kind":"Gdef","module_hidden":true,"module_public":false},"Generator":{".class":"SymbolTableNode","cross_ref":"typing.Generator","kind":"Gdef","module_hidden":true,"module_public":false},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.lib._arrayterator_impl.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._arrayterator_impl.TypeAlias","source_any":null,"type_of_any":3}}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing_extensions.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"_AnyIndex":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.lib._arrayterator_impl._AnyIndex","name":"_AnyIndex","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._arrayterator_impl.TypeAlias","source_any":null,"type_of_any":3}}},"_AnyShape":{".class":"SymbolTableNode","cross_ref":"numpy._typing._shape._AnyShape","kind":"Gdef","module_hidden":true,"module_public":false},"_DTypeT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arrayterator_impl._DTypeT","name":"_DTypeT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}},"_DTypeT_co":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.lib._arrayterator_impl._DTypeT_co","name":"_DTypeT_co","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}},"_ScalarT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._arrayterator_impl._ScalarT","name":"_ScalarT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},"_Shape":{".class":"SymbolTableNode","cross_ref":"numpy._typing._shape._Shape","kind":"Gdef","module_hidden":true,"module_public":false},"_ShapeT_co":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.lib._arrayterator_impl._ShapeT_co","name":"_ShapeT_co","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib._arrayterator_impl.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._arrayterator_impl.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._arrayterator_impl.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._arrayterator_impl.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._arrayterator_impl.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._arrayterator_impl.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._arrayterator_impl.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_arrayterator_impl.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_arrayterator_impl.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_arrayterator_impl.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..2e83619188f69145f5c4979f02895c14f4a6f13b --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_arrayterator_impl.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[3,10,4,5,7,9,1,1,1,1],"dep_prios":[5,5,5,5,5,10,5,30,30,30],"dependencies":["collections.abc","numpy._typing","types","typing","typing_extensions","numpy","builtins","_frozen_importlib","_typeshed","abc"],"hash":"c4ac1a414d4672e15d75d7184bc9777c2e3d060a","id":"numpy.lib._arrayterator_impl","ignore_all":true,"interface_hash":"8566acdd9290085e26b2b7286a482b48de127b68","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_arrayterator_impl.pyi","plugin_data":null,"size":1876,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_datasource.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_datasource.data.json new file mode 100644 index 0000000000000000000000000000000000000000..61a045a816f02f92c7301cba1c76655461e79439 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_datasource.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.lib._datasource","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"DataSource":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.lib._datasource.DataSource","name":"DataSource","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.lib._datasource.DataSource","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.lib._datasource","mro":["numpy.lib._datasource.DataSource","builtins.object"],"names":{".class":"SymbolTable","__del__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._datasource.DataSource.__del__","name":"__del__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["numpy.lib._datasource.DataSource"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__del__ of DataSource","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":[null,"destpath"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._datasource.DataSource.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":[null,"destpath"],"arg_types":["numpy.lib._datasource.DataSource",{".class":"UnionType","items":["pathlib.Path","builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of DataSource","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"abspath":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"path"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._datasource.DataSource.abspath","name":"abspath","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"path"],"arg_types":["numpy.lib._datasource.DataSource","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"abspath of DataSource","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"exists":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"path"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._datasource.DataSource.exists","name":"exists","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"path"],"arg_types":["numpy.lib._datasource.DataSource","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"exists of DataSource","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"open":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":[null,"path","mode","encoding","newline"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._datasource.DataSource.open","name":"open","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":[null,"path","mode","encoding","newline"],"arg_types":["numpy.lib._datasource.DataSource","builtins.str",{".class":"AnyType","missing_import_name":"numpy.lib._datasource.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"open of DataSource","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.IO"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._datasource.DataSource.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.lib._datasource.DataSource","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"IO":{".class":"SymbolTableNode","cross_ref":"typing.IO","kind":"Gdef","module_hidden":true,"module_public":false},"OpenBinaryMode":{".class":"SymbolTableNode","cross_ref":"_typeshed.OpenBinaryMode","kind":"Gdef","module_hidden":true,"module_public":false},"OpenTextMode":{".class":"SymbolTableNode","cross_ref":"_typeshed.OpenTextMode","kind":"Gdef","module_hidden":true,"module_public":false},"Path":{".class":"SymbolTableNode","cross_ref":"pathlib.Path","kind":"Gdef","module_hidden":true,"module_public":false},"Repository":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy.lib._datasource.DataSource"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.lib._datasource.Repository","name":"Repository","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.lib._datasource.Repository","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.lib._datasource","mro":["numpy.lib._datasource.Repository","numpy.lib._datasource.DataSource","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":[null,"baseurl","destpath"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._datasource.Repository.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":[null,"baseurl","destpath"],"arg_types":["numpy.lib._datasource.Repository","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of Repository","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"listdir":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._datasource.Repository.listdir","name":"listdir","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["numpy.lib._datasource.Repository"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"listdir of Repository","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._datasource.Repository.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.lib._datasource.Repository","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.lib._datasource.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._datasource.TypeAlias","source_any":null,"type_of_any":3}}},"_Mode":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.lib._datasource._Mode","name":"_Mode","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._datasource.TypeAlias","source_any":null,"type_of_any":3}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._datasource.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._datasource.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._datasource.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._datasource.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._datasource.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._datasource.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"open":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["path","mode","destpath","encoding","newline"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._datasource.open","name":"open","original_first_arg":"path","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["path","mode","destpath","encoding","newline"],"arg_types":["builtins.str",{".class":"AnyType","missing_import_name":"numpy.lib._datasource.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"open","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.IO"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_datasource.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_datasource.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_datasource.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..d73c36d74db62dfa2500858f5a871d50e88c352a --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_datasource.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106713,"dep_lines":[1,2,4,1,1,1,1],"dep_prios":[5,5,5,5,30,30,30],"dependencies":["pathlib","typing","_typeshed","builtins","_frozen_importlib","abc","os"],"hash":"5852af4ea1039a9549d263f6bc82e28d3ba2ff6d","id":"numpy.lib._datasource","ignore_all":true,"interface_hash":"0f195e51d2d675b42635eb0f21943254cbc65195","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_datasource.pyi","plugin_data":null,"size":996,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_format_impl.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_format_impl.data.json new file mode 100644 index 0000000000000000000000000000000000000000..0d2f9fd1eb57a513fe72d15bca3944b794ad9cae --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_format_impl.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.lib._format_impl","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","ARRAY_ALIGN":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._format_impl.ARRAY_ALIGN","name":"ARRAY_ALIGN","setter_type":null,"type":{".class":"LiteralType","fallback":"builtins.int","value":64}}},"BUFFER_SIZE":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._format_impl.BUFFER_SIZE","name":"BUFFER_SIZE","setter_type":null,"type":{".class":"LiteralType","fallback":"builtins.int","value":262144}}},"EXPECTED_KEYS":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy.lib._format_impl.EXPECTED_KEYS","name":"EXPECTED_KEYS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"Final":{".class":"SymbolTableNode","cross_ref":"typing.Final","kind":"Gdef","module_hidden":true,"module_public":false},"GROWTH_AXIS_MAX_DIGITS":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._format_impl.GROWTH_AXIS_MAX_DIGITS","name":"GROWTH_AXIS_MAX_DIGITS","setter_type":null,"type":{".class":"LiteralType","fallback":"builtins.int","value":21}}},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"MAGIC_LEN":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._format_impl.MAGIC_LEN","name":"MAGIC_LEN","setter_type":null,"type":{".class":"LiteralType","fallback":"builtins.int","value":8}}},"MAGIC_PREFIX":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy.lib._format_impl.MAGIC_PREFIX","name":"MAGIC_PREFIX","setter_type":null,"type":"builtins.bytes"}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.lib._format_impl.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._format_impl.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._format_impl.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._format_impl.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._format_impl.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._format_impl.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._format_impl.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"descr_to_dtype":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["descr"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._format_impl.descr_to_dtype","name":"descr_to_dtype","original_first_arg":"descr","type":null}},"drop_metadata":{".class":"SymbolTableNode","cross_ref":"numpy.lib._utils_impl.drop_metadata","kind":"Gdef","module_hidden":true,"module_public":false},"dtype_to_descr":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._format_impl.dtype_to_descr","name":"dtype_to_descr","original_first_arg":"dtype","type":null}},"header_data_from_array_1_0":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["array"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._format_impl.header_data_from_array_1_0","name":"header_data_from_array_1_0","original_first_arg":"array","type":null}},"isfileobj":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["f"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._format_impl.isfileobj","name":"isfileobj","original_first_arg":"f","type":null}},"magic":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["major","minor"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._format_impl.magic","name":"magic","original_first_arg":"major","type":null}},"open_memmap":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1],"arg_names":["filename","mode","dtype","shape","fortran_order","version"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._format_impl.open_memmap","name":"open_memmap","original_first_arg":"filename","type":null}},"read_array":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["fp","allow_pickle","pickle_kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._format_impl.read_array","name":"read_array","original_first_arg":"fp","type":null}},"read_array_header_1_0":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["fp"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._format_impl.read_array_header_1_0","name":"read_array_header_1_0","original_first_arg":"fp","type":null}},"read_array_header_2_0":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["fp"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._format_impl.read_array_header_2_0","name":"read_array_header_2_0","original_first_arg":"fp","type":null}},"read_magic":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["fp"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._format_impl.read_magic","name":"read_magic","original_first_arg":"fp","type":null}},"write_array":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["fp","array","version","allow_pickle","pickle_kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._format_impl.write_array","name":"write_array","original_first_arg":"fp","type":null}},"write_array_header_1_0":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["fp","d"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._format_impl.write_array_header_1_0","name":"write_array_header_1_0","original_first_arg":"fp","type":null}},"write_array_header_2_0":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["fp","d"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._format_impl.write_array_header_2_0","name":"write_array_header_2_0","original_first_arg":"fp","type":null}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_format_impl.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_format_impl.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_format_impl.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..08fc14201e45150acec6c8baf19b2dd1d1bea212 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_format_impl.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[3,1,1,1,1],"dep_prios":[5,5,5,30,30],"dependencies":["numpy.lib._utils_impl","typing","builtins","_frozen_importlib","abc"],"hash":"652a23f527767e330b95d47df015d86b19a0618a","id":"numpy.lib._format_impl","ignore_all":true,"interface_hash":"cdf6ce9e9d2bc41cbb3513a6f0b4660ef18a9ab1","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_format_impl.pyi","plugin_data":null,"size":869,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_function_base_impl.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_function_base_impl.data.json new file mode 100644 index 0000000000000000000000000000000000000000..8007ca42c7b4d6ff0a4ca6e45285a562ea3d5f26 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_function_base_impl.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.lib._function_base_impl","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef","module_hidden":true,"module_public":false},"Concatenate":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.Concatenate","name":"Concatenate","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.Concatenate","source_any":null,"type_of_any":3}}},"DTypeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like.DTypeLike","kind":"Gdef","module_hidden":true,"module_public":false},"Incomplete":{".class":"SymbolTableNode","cross_ref":"_typeshed.Incomplete","kind":"Gdef","module_hidden":true,"module_public":false},"Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef","module_hidden":true,"module_public":false},"L":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"ParamSpec":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.ParamSpec","name":"ParamSpec","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.ParamSpec","source_any":null,"type_of_any":3}}},"Protocol":{".class":"SymbolTableNode","cross_ref":"typing.Protocol","kind":"Gdef","module_hidden":true,"module_public":false},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef","module_hidden":true,"module_public":false},"SupportsIndex":{".class":"SymbolTableNode","cross_ref":"typing.SupportsIndex","kind":"Gdef","module_hidden":true,"module_public":false},"SupportsInt":{".class":"SymbolTableNode","cross_ref":"typing.SupportsInt","kind":"Gdef","module_hidden":true,"module_public":false},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3}}},"TypeIs":{".class":"SymbolTableNode","cross_ref":"typing_extensions.TypeIs","kind":"Gdef","module_hidden":true,"module_public":false},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"_2Tuple":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.lib._function_base_impl._2Tuple","name":"_2Tuple","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3}}},"_ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeBool_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeBool_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeComplex_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeComplex_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeDT64_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeDT64_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeFloat_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeFloat_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeInt_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeInt_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeNumber_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeNumber_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeObject_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeObject_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeTD64_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeTD64_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","name":"_ArrayT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}},"_ComplexLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._ComplexLike_co","kind":"Gdef","module_hidden":true,"module_public":false},"_DTypeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._DTypeLike","kind":"Gdef","module_hidden":true,"module_public":false},"_FloatLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._FloatLike_co","kind":"Gdef","module_hidden":true,"module_public":false},"_MeshgridIdx":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.lib._function_base_impl._MeshgridIdx","name":"_MeshgridIdx","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3}}},"_MethodKind":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy.lib._function_base_impl._MethodKind","line":602,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"inverted_cdf"},{".class":"LiteralType","fallback":"builtins.str","value":"averaged_inverted_cdf"},{".class":"LiteralType","fallback":"builtins.str","value":"closest_observation"},{".class":"LiteralType","fallback":"builtins.str","value":"interpolated_inverted_cdf"},{".class":"LiteralType","fallback":"builtins.str","value":"hazen"},{".class":"LiteralType","fallback":"builtins.str","value":"weibull"},{".class":"LiteralType","fallback":"builtins.str","value":"linear"},{".class":"LiteralType","fallback":"builtins.str","value":"median_unbiased"},{".class":"LiteralType","fallback":"builtins.str","value":"normal_unbiased"},{".class":"LiteralType","fallback":"builtins.str","value":"lower"},{".class":"LiteralType","fallback":"builtins.str","value":"higher"},{".class":"LiteralType","fallback":"builtins.str","value":"midpoint"},{".class":"LiteralType","fallback":"builtins.str","value":"nearest"}],"uses_pep604_syntax":false}}},"_NestedSequence":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nested_sequence._NestedSequence","kind":"Gdef","module_hidden":true,"module_public":false},"_NoValueType":{".class":"SymbolTableNode","cross_ref":"numpy._globals._NoValueType","kind":"Gdef","module_hidden":true,"module_public":false},"_NumberLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._NumberLike_co","kind":"Gdef","module_hidden":true,"module_public":false},"_OrderKACF":{".class":"SymbolTableNode","cross_ref":"numpy._OrderKACF","kind":"Gdef","module_hidden":true,"module_public":false},"_Pss":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib._function_base_impl._Pss","name":"_Pss","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.ParamSpec","source_any":{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.ParamSpec","source_any":null,"type_of_any":3},"type_of_any":7}}},"_ScalarLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._ScalarLike_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ScalarT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","name":"_ScalarT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},"_ScalarT1":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT1","name":"_ScalarT1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},"_ScalarT2":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT2","name":"_ScalarT2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},"_ScalarT_fm":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT_fm","name":"_ScalarT_fm","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"}],"uses_pep604_syntax":true},"values":[],"variance":0}},"_ShapeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._shape._ShapeLike","kind":"Gdef","module_hidden":true,"module_public":false},"_SupportsRMulFloat":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.lib._function_base_impl._SupportsRMulFloat","name":"_SupportsRMulFloat","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._function_base_impl._SupportsRMulFloat","upper_bound":"builtins.object","values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy.lib._function_base_impl._SupportsRMulFloat","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.lib._function_base_impl","mro":["numpy.lib._function_base_impl._SupportsRMulFloat","builtins.object"],"names":{".class":"SymbolTable","__rmul__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._function_base_impl._SupportsRMulFloat.__rmul__","name":"__rmul__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._function_base_impl._SupportsRMulFloat","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._function_base_impl._SupportsRMulFloat"},"builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__rmul__ of _SupportsRMulFloat","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._function_base_impl._SupportsRMulFloat","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._SupportsRMulFloat.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._function_base_impl._SupportsRMulFloat","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._function_base_impl._SupportsRMulFloat"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_T_co"],"typeddict_type":null}},"_T":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T","name":"_T","upper_bound":"builtins.object","values":[],"variance":0}},"_T_co":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T_co","name":"_T_co","upper_bound":"builtins.object","values":[],"variance":1}},"_TrimZerosSequence":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.lib._function_base_impl._TrimZerosSequence","name":"_TrimZerosSequence","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._function_base_impl._TrimZerosSequence","upper_bound":"builtins.object","values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy.lib._function_base_impl._TrimZerosSequence","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.lib._function_base_impl","mro":["numpy.lib._function_base_impl._TrimZerosSequence","builtins.object"],"names":{".class":"SymbolTable","__getitem__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._function_base_impl._TrimZerosSequence.__getitem__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.lib._function_base_impl._TrimZerosSequence.__getitem__","name":"__getitem__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._function_base_impl._TrimZerosSequence","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._function_base_impl._TrimZerosSequence"},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of _TrimZerosSequence","ret_type":"builtins.object","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl._TrimZerosSequence.__getitem__","name":"__getitem__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._function_base_impl._TrimZerosSequence","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._function_base_impl._TrimZerosSequence"},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of _TrimZerosSequence","ret_type":"builtins.object","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.lib._function_base_impl._TrimZerosSequence.__getitem__","name":"__getitem__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._function_base_impl._TrimZerosSequence","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._function_base_impl._TrimZerosSequence"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.slice"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of _TrimZerosSequence","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._function_base_impl._TrimZerosSequence","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl._TrimZerosSequence.__getitem__","name":"__getitem__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._function_base_impl._TrimZerosSequence","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._function_base_impl._TrimZerosSequence"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.slice"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of _TrimZerosSequence","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._function_base_impl._TrimZerosSequence","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._function_base_impl._TrimZerosSequence","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._function_base_impl._TrimZerosSequence"},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of _TrimZerosSequence","ret_type":"builtins.object","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._function_base_impl._TrimZerosSequence","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._function_base_impl._TrimZerosSequence"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.slice"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of _TrimZerosSequence","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._function_base_impl._TrimZerosSequence","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"__len__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._function_base_impl._TrimZerosSequence.__len__","name":"__len__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._function_base_impl._TrimZerosSequence","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._function_base_impl._TrimZerosSequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__len__ of _TrimZerosSequence","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._TrimZerosSequence.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._function_base_impl._TrimZerosSequence","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._function_base_impl._TrimZerosSequence"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_T_co"],"typeddict_type":null}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib._function_base_impl.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._function_base_impl.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._function_base_impl.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._function_base_impl.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._function_base_impl.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._function_base_impl.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._function_base_impl.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"angle":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._function_base_impl.angle","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["z","deg"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.angle","name":"angle","original_first_arg":"z","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["z","deg"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"angle","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.angle","name":"angle","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["z","deg"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"angle","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["z","deg"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.angle","name":"angle","original_first_arg":"z","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["z","deg"],"arg_types":["numpy.object_","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"angle","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.angle","name":"angle","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["z","deg"],"arg_types":["numpy.object_","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"angle","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["z","deg"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.angle","name":"angle","original_first_arg":"z","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["z","deg"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"angle","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.angle","name":"angle","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["z","deg"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"angle","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["z","deg"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.angle","name":"angle","original_first_arg":"z","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["z","deg"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"angle","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.angle","name":"angle","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["z","deg"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"angle","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["z","deg"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"angle","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["z","deg"],"arg_types":["numpy.object_","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"angle","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["z","deg"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"angle","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["z","deg"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"angle","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"append":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["arr","values","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._function_base_impl.append","name":"append","original_first_arg":"arr","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["arr","values","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"append","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"asarray_chkfinite":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._function_base_impl.asarray_chkfinite","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["a","dtype","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.asarray_chkfinite","name":"asarray_chkfinite","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","dtype","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray_chkfinite","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.asarray_chkfinite#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.asarray_chkfinite","name":"asarray_chkfinite","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","dtype","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray_chkfinite","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.asarray_chkfinite#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["a","dtype","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.asarray_chkfinite","name":"asarray_chkfinite","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","dtype","order"],"arg_types":["builtins.object",{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray_chkfinite","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.asarray_chkfinite","name":"asarray_chkfinite","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","dtype","order"],"arg_types":["builtins.object",{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray_chkfinite","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","dtype","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.asarray_chkfinite","name":"asarray_chkfinite","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","dtype","order"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray_chkfinite","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.asarray_chkfinite#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.asarray_chkfinite","name":"asarray_chkfinite","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","dtype","order"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray_chkfinite","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.asarray_chkfinite#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","dtype","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.asarray_chkfinite","name":"asarray_chkfinite","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","dtype","order"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray_chkfinite","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.asarray_chkfinite","name":"asarray_chkfinite","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","dtype","order"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray_chkfinite","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","dtype","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray_chkfinite","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.asarray_chkfinite#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","dtype","order"],"arg_types":["builtins.object",{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray_chkfinite","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","dtype","order"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray_chkfinite","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.asarray_chkfinite#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","dtype","order"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asarray_chkfinite","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"average":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._function_base_impl.average","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","weights","returned","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.average","name":"average","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","weights","returned","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"average","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.average","name":"average","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","weights","returned","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"average","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,3,5],"arg_names":["a","axis","weights","returned","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.average","name":"average","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["a","axis","weights","returned","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"average","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.average","name":"average","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["a","axis","weights","returned","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"average","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","weights","returned","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.average","name":"average","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","weights","returned","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"average","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.average","name":"average","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","weights","returned","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"average","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,3,5],"arg_names":["a","axis","weights","returned","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.average","name":"average","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["a","axis","weights","returned","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"average","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.average","name":"average","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["a","axis","weights","returned","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"average","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,3,5],"arg_names":["a","axis","weights","returned","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.average","name":"average","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["a","axis","weights","returned","keepdims"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.object",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["builtins.bool",{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"average","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.average","name":"average","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["a","axis","weights","returned","keepdims"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.object",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["builtins.bool",{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"average","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","weights","returned","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.average","name":"average","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","weights","returned","keepdims"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.object",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"average","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.average","name":"average","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","weights","returned","keepdims"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.object",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"average","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","weights","returned","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"average","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["a","axis","weights","returned","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"average","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","weights","returned","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"average","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["a","axis","weights","returned","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"average","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["a","axis","weights","returned","keepdims"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.object",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":["builtins.bool",{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"average","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["a","axis","weights","returned","keepdims"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.object",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"average","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"bartlett":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["M"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._function_base_impl.bartlett","name":"bartlett","original_first_arg":"M","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["M"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"bartlett","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"bincount":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.bincount","kind":"Gdef"},"blackman":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["M"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._function_base_impl.blackman","name":"blackman","original_first_arg":"M","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["M"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"blackman","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"bool_":{".class":"SymbolTableNode","cross_ref":"numpy.bool_","kind":"Gdef","module_hidden":true,"module_public":false},"complex128":{".class":"SymbolTableNode","cross_ref":"numpy.complex128","kind":"Gdef","module_hidden":true,"module_public":false},"complexfloating":{".class":"SymbolTableNode","cross_ref":"numpy.complexfloating","kind":"Gdef","module_hidden":true,"module_public":false},"copy":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._function_base_impl.copy","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["a","order","subok"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.copy","name":"copy","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["a","order","subok"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.copy#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"copy","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.copy#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.copy#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.copy","name":"copy","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["a","order","subok"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.copy#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"copy","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.copy#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.copy#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3],"arg_names":["a","order","subok"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.copy","name":"copy","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,3],"arg_names":["a","order","subok"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.copy#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"copy","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.copy#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.copy#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.copy","name":"copy","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3],"arg_names":["a","order","subok"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.copy#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"copy","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.copy#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.copy#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["a","order","subok"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.copy","name":"copy","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","order","subok"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"copy","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.copy#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.copy","name":"copy","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","order","subok"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"copy","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.copy#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["a","order","subok"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.copy","name":"copy","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","order","subok"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"copy","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.copy","name":"copy","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","order","subok"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"copy","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["a","order","subok"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.copy#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"copy","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.copy#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.copy#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3],"arg_names":["a","order","subok"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.copy#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"copy","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.copy#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.copy#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","order","subok"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"copy","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.copy#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","order","subok"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"copy","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"corrcoef":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._function_base_impl.corrcoef","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,5],"arg_names":["x","y","rowvar","bias","ddof","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.corrcoef","name":"corrcoef","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["x","y","rowvar","bias","ddof","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","numpy._globals._NoValueType","numpy._globals._NoValueType",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"corrcoef","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.corrcoef","name":"corrcoef","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["x","y","rowvar","bias","ddof","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","numpy._globals._NoValueType","numpy._globals._NoValueType",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"corrcoef","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,5],"arg_names":["x","y","rowvar","bias","ddof","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.corrcoef","name":"corrcoef","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["x","y","rowvar","bias","ddof","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","numpy._globals._NoValueType","numpy._globals._NoValueType",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"corrcoef","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.corrcoef","name":"corrcoef","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["x","y","rowvar","bias","ddof","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","numpy._globals._NoValueType","numpy._globals._NoValueType",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"corrcoef","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,3],"arg_names":["x","y","rowvar","bias","ddof","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.corrcoef","name":"corrcoef","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,3],"arg_names":["x","y","rowvar","bias","ddof","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","numpy._globals._NoValueType","numpy._globals._NoValueType",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"corrcoef","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.corrcoef#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.corrcoef","name":"corrcoef","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,3],"arg_names":["x","y","rowvar","bias","ddof","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","numpy._globals._NoValueType","numpy._globals._NoValueType",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"corrcoef","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.corrcoef#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,5],"arg_names":["x","y","rowvar","bias","ddof","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.corrcoef","name":"corrcoef","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["x","y","rowvar","bias","ddof","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","numpy._globals._NoValueType","numpy._globals._NoValueType",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"corrcoef","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.corrcoef","name":"corrcoef","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["x","y","rowvar","bias","ddof","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","numpy._globals._NoValueType","numpy._globals._NoValueType",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"corrcoef","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["x","y","rowvar","bias","ddof","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","numpy._globals._NoValueType","numpy._globals._NoValueType",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"corrcoef","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["x","y","rowvar","bias","ddof","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","numpy._globals._NoValueType","numpy._globals._NoValueType",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"corrcoef","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,3],"arg_names":["x","y","rowvar","bias","ddof","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","numpy._globals._NoValueType","numpy._globals._NoValueType",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"corrcoef","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.corrcoef#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["x","y","rowvar","bias","ddof","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","numpy._globals._NoValueType","numpy._globals._NoValueType",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"corrcoef","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"cov":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._function_base_impl.cov","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1,5],"arg_names":["m","y","rowvar","bias","ddof","fweights","aweights","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.cov","name":"cov","original_first_arg":"m","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,5],"arg_names":["m","y","rowvar","bias","ddof","fweights","aweights","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool",{".class":"UnionType","items":["typing.SupportsIndex","typing.SupportsInt",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cov","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.cov","name":"cov","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,5],"arg_names":["m","y","rowvar","bias","ddof","fweights","aweights","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool",{".class":"UnionType","items":["typing.SupportsIndex","typing.SupportsInt",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cov","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1,5],"arg_names":["m","y","rowvar","bias","ddof","fweights","aweights","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.cov","name":"cov","original_first_arg":"m","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,5],"arg_names":["m","y","rowvar","bias","ddof","fweights","aweights","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool",{".class":"UnionType","items":["typing.SupportsIndex","typing.SupportsInt",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cov","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.cov","name":"cov","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,5],"arg_names":["m","y","rowvar","bias","ddof","fweights","aweights","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool",{".class":"UnionType","items":["typing.SupportsIndex","typing.SupportsInt",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cov","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1,3],"arg_names":["m","y","rowvar","bias","ddof","fweights","aweights","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.cov","name":"cov","original_first_arg":"m","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,3],"arg_names":["m","y","rowvar","bias","ddof","fweights","aweights","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool",{".class":"UnionType","items":["typing.SupportsIndex","typing.SupportsInt",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cov","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.cov#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.cov","name":"cov","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,3],"arg_names":["m","y","rowvar","bias","ddof","fweights","aweights","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool",{".class":"UnionType","items":["typing.SupportsIndex","typing.SupportsInt",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cov","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.cov#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1,3],"arg_names":["m","y","rowvar","bias","ddof","fweights","aweights","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.cov","name":"cov","original_first_arg":"m","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,3],"arg_names":["m","y","rowvar","bias","ddof","fweights","aweights","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool",{".class":"UnionType","items":["typing.SupportsIndex","typing.SupportsInt",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cov","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.cov","name":"cov","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,3],"arg_names":["m","y","rowvar","bias","ddof","fweights","aweights","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool",{".class":"UnionType","items":["typing.SupportsIndex","typing.SupportsInt",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cov","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,5],"arg_names":["m","y","rowvar","bias","ddof","fweights","aweights","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool",{".class":"UnionType","items":["typing.SupportsIndex","typing.SupportsInt",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cov","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,5],"arg_names":["m","y","rowvar","bias","ddof","fweights","aweights","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool",{".class":"UnionType","items":["typing.SupportsIndex","typing.SupportsInt",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cov","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,3],"arg_names":["m","y","rowvar","bias","ddof","fweights","aweights","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool",{".class":"UnionType","items":["typing.SupportsIndex","typing.SupportsInt",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cov","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.cov#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,3],"arg_names":["m","y","rowvar","bias","ddof","fweights","aweights","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool",{".class":"UnionType","items":["typing.SupportsIndex","typing.SupportsInt",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cov","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"datetime64":{".class":"SymbolTableNode","cross_ref":"numpy.datetime64","kind":"Gdef","module_hidden":true,"module_public":false},"delete":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._function_base_impl.delete","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["arr","obj","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.delete","name":"delete","original_first_arg":"arr","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["arr","obj","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.slice"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"delete","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.delete#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.delete","name":"delete","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["arr","obj","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.slice"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"delete","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.delete#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["arr","obj","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.delete","name":"delete","original_first_arg":"arr","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["arr","obj","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.slice"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"delete","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.delete","name":"delete","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["arr","obj","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.slice"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"delete","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["arr","obj","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.slice"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"delete","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.delete#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["arr","obj","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.slice"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"delete","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"deprecated":{".class":"SymbolTableNode","cross_ref":"typing_extensions.deprecated","kind":"Gdef","module_hidden":true,"module_public":false},"diff":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._function_base_impl.diff","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["a","n","axis","prepend","append"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.diff","name":"diff","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","n","axis","prepend","append"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._function_base_impl.diff#0","upper_bound":"builtins.object","values":[],"variance":0},{".class":"LiteralType","fallback":"builtins.int","value":0},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"diff","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._function_base_impl.diff#0","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._function_base_impl.diff#0","upper_bound":"builtins.object","values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.diff","name":"diff","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","n","axis","prepend","append"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._function_base_impl.diff#0","upper_bound":"builtins.object","values":[],"variance":0},{".class":"LiteralType","fallback":"builtins.int","value":0},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"diff","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._function_base_impl.diff#0","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._function_base_impl.diff#0","upper_bound":"builtins.object","values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["a","n","axis","prepend","append"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.diff","name":"diff","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","n","axis","prepend","append"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int","typing.SupportsIndex",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"diff","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.diff","name":"diff","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","n","axis","prepend","append"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int","typing.SupportsIndex",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"diff","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","n","axis","prepend","append"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._function_base_impl.diff#0","upper_bound":"builtins.object","values":[],"variance":0},{".class":"LiteralType","fallback":"builtins.int","value":0},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"diff","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._function_base_impl.diff#0","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._function_base_impl.diff#0","upper_bound":"builtins.object","values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","n","axis","prepend","append"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int","typing.SupportsIndex",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"diff","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"digitize":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._function_base_impl.digitize","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["x","bins","right"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.digitize","name":"digitize","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["x","bins","right"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"digitize","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.digitize","name":"digitize","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["x","bins","right"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"digitize","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["x","bins","right"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.digitize","name":"digitize","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["x","bins","right"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"digitize","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.digitize","name":"digitize","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["x","bins","right"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"digitize","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["x","bins","right"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"digitize","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["x","bins","right"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"digitize","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"extract":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._function_base_impl.extract","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["condition","arr"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.extract","name":"extract","original_first_arg":"condition","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["condition","arr"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"extract","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.extract#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.extract","name":"extract","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["condition","arr"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"extract","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.extract#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["condition","arr"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.extract","name":"extract","original_first_arg":"condition","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["condition","arr"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"extract","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.extract","name":"extract","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["condition","arr"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"extract","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["condition","arr"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"extract","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.extract#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["condition","arr"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"extract","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"flip":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._function_base_impl.flip","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["m","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.flip","name":"flip","original_first_arg":"m","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["m","axis"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.flip#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"flip","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.flip#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.flip#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.flip","name":"flip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["m","axis"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.flip#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"flip","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.flip#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.flip#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["m","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.flip","name":"flip","original_first_arg":"m","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["m","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"flip","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.flip","name":"flip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["m","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"flip","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["m","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.flip","name":"flip","original_first_arg":"m","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["m","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"flip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.flip#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.flip","name":"flip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["m","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"flip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.flip#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["m","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.flip","name":"flip","original_first_arg":"m","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["m","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"flip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.flip","name":"flip","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["m","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"flip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["m","axis"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.flip#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"flip","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.flip#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.flip#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["m","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"flip","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["m","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"flip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.flip#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["m","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"flip","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"float64":{".class":"SymbolTableNode","cross_ref":"numpy.float64","kind":"Gdef","module_hidden":true,"module_public":false},"floating":{".class":"SymbolTableNode","cross_ref":"numpy.floating","kind":"Gdef","module_hidden":true,"module_public":false},"generic":{".class":"SymbolTableNode","cross_ref":"numpy.generic","kind":"Gdef","module_hidden":true,"module_public":false},"gradient":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,5,5],"arg_names":["f","varargs","axis","edge_order"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._function_base_impl.gradient","name":"gradient","original_first_arg":"f","type":{".class":"CallableType","arg_kinds":[0,2,5,5],"arg_names":["f","varargs","axis","edge_order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"LiteralType","fallback":"builtins.int","value":2}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"gradient","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"hamming":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["M"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._function_base_impl.hamming","name":"hamming","original_first_arg":"M","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["M"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hamming","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"hanning":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["M"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._function_base_impl.hanning","name":"hanning","original_first_arg":"M","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["M"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hanning","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"i0":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._function_base_impl.i0","name":"i0","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"i0","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"insert":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._function_base_impl.insert","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["arr","obj","values","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.insert","name":"insert","original_first_arg":"arr","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["arr","obj","values","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.slice"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"insert","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.insert#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.insert","name":"insert","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["arr","obj","values","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.slice"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"insert","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.insert#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["arr","obj","values","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.insert","name":"insert","original_first_arg":"arr","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["arr","obj","values","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.slice"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"insert","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.insert","name":"insert","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["arr","obj","values","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.slice"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"insert","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["arr","obj","values","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.slice"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"insert","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.insert#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["arr","obj","values","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.slice"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"insert","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"integer":{".class":"SymbolTableNode","cross_ref":"numpy.integer","kind":"Gdef","module_hidden":true,"module_public":false},"interp":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._function_base_impl.interp","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1],"arg_names":["x","xp","fp","left","right","period"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.interp","name":"interp","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","xp","fp","left","right","period"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"interp","ret_type":"numpy.float64","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.interp","name":"interp","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","xp","fp","left","right","period"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"interp","ret_type":"numpy.float64","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1],"arg_names":["x","xp","fp","left","right","period"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.interp","name":"interp","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","xp","fp","left","right","period"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"interp","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.interp","name":"interp","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","xp","fp","left","right","period"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"interp","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1],"arg_names":["x","xp","fp","left","right","period"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.interp","name":"interp","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","xp","fp","left","right","period"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"interp","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy.float64"],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.interp","name":"interp","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","xp","fp","left","right","period"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"interp","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy.float64"],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1],"arg_names":["x","xp","fp","left","right","period"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.interp","name":"interp","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","xp","fp","left","right","period"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"interp","ret_type":"numpy.complex128","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.interp","name":"interp","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","xp","fp","left","right","period"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"interp","ret_type":"numpy.complex128","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1],"arg_names":["x","xp","fp","left","right","period"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.interp","name":"interp","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","xp","fp","left","right","period"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":["builtins.complex",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"interp","ret_type":{".class":"UnionType","items":["numpy.complex128","numpy.float64"],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.interp","name":"interp","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","xp","fp","left","right","period"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":["builtins.complex",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"interp","ret_type":{".class":"UnionType","items":["numpy.complex128","numpy.float64"],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1],"arg_names":["x","xp","fp","left","right","period"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.interp","name":"interp","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","xp","fp","left","right","period"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"interp","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.interp","name":"interp","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","xp","fp","left","right","period"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"interp","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1],"arg_names":["x","xp","fp","left","right","period"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.interp","name":"interp","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","xp","fp","left","right","period"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":["builtins.complex",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"interp","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.interp","name":"interp","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","xp","fp","left","right","period"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":["builtins.complex",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"interp","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1],"arg_names":["x","xp","fp","left","right","period"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.interp","name":"interp","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","xp","fp","left","right","period"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"interp","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy.complex128"],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.interp","name":"interp","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","xp","fp","left","right","period"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"interp","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy.complex128"],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1],"arg_names":["x","xp","fp","left","right","period"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.interp","name":"interp","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","xp","fp","left","right","period"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"interp","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy.complex128","numpy.float64"],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.interp","name":"interp","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","xp","fp","left","right","period"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"interp","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy.complex128","numpy.float64"],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","xp","fp","left","right","period"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"interp","ret_type":"numpy.float64","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","xp","fp","left","right","period"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"interp","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","xp","fp","left","right","period"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"interp","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy.float64"],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","xp","fp","left","right","period"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"interp","ret_type":"numpy.complex128","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","xp","fp","left","right","period"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":["builtins.complex",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"interp","ret_type":{".class":"UnionType","items":["numpy.complex128","numpy.float64"],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","xp","fp","left","right","period"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"interp","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","xp","fp","left","right","period"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":["builtins.complex",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"interp","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","xp","fp","left","right","period"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"interp","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy.complex128"],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","xp","fp","left","right","period"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"interp","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy.complex128","numpy.float64"],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"intp":{".class":"SymbolTableNode","cross_ref":"numpy.intp","kind":"Gdef","module_hidden":true,"module_public":false},"iterable":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["y"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._function_base_impl.iterable","name":"iterable","original_first_arg":"y","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["y"],"arg_types":["builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"iterable","ret_type":"builtins.bool","type_guard":null,"type_is":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Iterable"},"unpack_kwargs":false,"variables":[]}}},"kaiser":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["M","beta"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._function_base_impl.kaiser","name":"kaiser","original_first_arg":"M","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["M","beta"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"kaiser","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"median":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._function_base_impl.median","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["a","axis","out","overwrite_input","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.median","name":"median","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","axis","out","overwrite_input","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"median","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.median","name":"median","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","axis","out","overwrite_input","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"median","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["a","axis","out","overwrite_input","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.median","name":"median","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","axis","out","overwrite_input","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"median","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.median","name":"median","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","axis","out","overwrite_input","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"median","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["a","axis","out","overwrite_input","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.median","name":"median","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","axis","out","overwrite_input","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"median","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.median","name":"median","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","axis","out","overwrite_input","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"median","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["a","axis","out","overwrite_input","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.median","name":"median","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","axis","out","overwrite_input","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"median","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.median","name":"median","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","axis","out","overwrite_input","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"median","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["a","axis","out","overwrite_input","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.median","name":"median","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","axis","out","overwrite_input","keepdims"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"median","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.median","name":"median","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","axis","out","overwrite_input","keepdims"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"median","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1],"arg_names":["a","axis","out","overwrite_input","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.median","name":"median","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1],"arg_names":["a","axis","out","overwrite_input","keepdims"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.median#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"median","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.median#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.median#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.median","name":"median","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1],"arg_names":["a","axis","out","overwrite_input","keepdims"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.median#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"median","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.median#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.median#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3,5,5],"arg_names":["a","axis","out","overwrite_input","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.median","name":"median","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,3,5,5],"arg_names":["a","axis","out","overwrite_input","keepdims"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.median","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"median","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.median","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.median","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.median","name":"median","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3,5,5],"arg_names":["a","axis","out","overwrite_input","keepdims"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.median","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"median","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.median","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.median","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","axis","out","overwrite_input","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"median","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","axis","out","overwrite_input","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"median","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","axis","out","overwrite_input","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"median","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","axis","out","overwrite_input","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"median","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","axis","out","overwrite_input","keepdims"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"median","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1],"arg_names":["a","axis","out","overwrite_input","keepdims"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.median#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"median","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.median#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.median#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5,5],"arg_names":["a","axis","out","overwrite_input","keepdims"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.median","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"median","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.median","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.median","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"meshgrid":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._function_base_impl.meshgrid","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5],"arg_names":["copy","sparse","indexing"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.meshgrid","name":"meshgrid","original_first_arg":"copy","type":{".class":"CallableType","arg_kinds":[5,5,5],"arg_names":["copy","sparse","indexing"],"arg_types":["builtins.bool","builtins.bool",{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"meshgrid","ret_type":{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.meshgrid","name":"meshgrid","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5],"arg_names":["copy","sparse","indexing"],"arg_types":["builtins.bool","builtins.bool",{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"meshgrid","ret_type":{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5],"arg_names":[null,"copy","sparse","indexing"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.meshgrid","name":"meshgrid","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":[null,"copy","sparse","indexing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.bool",{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"meshgrid","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.meshgrid#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.meshgrid","name":"meshgrid","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":[null,"copy","sparse","indexing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.bool",{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"meshgrid","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.meshgrid#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5],"arg_names":[null,"copy","sparse","indexing"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.meshgrid","name":"meshgrid","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":[null,"copy","sparse","indexing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.bool",{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"meshgrid","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.meshgrid","name":"meshgrid","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":[null,"copy","sparse","indexing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.bool",{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"meshgrid","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5],"arg_names":[null,null,"copy","sparse","indexing"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.meshgrid","name":"meshgrid","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5],"arg_names":[null,null,"copy","sparse","indexing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.bool",{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"meshgrid","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT1","id":-1,"name":"_ScalarT1","namespace":"numpy.lib._function_base_impl.meshgrid#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT2","id":-2,"name":"_ScalarT2","namespace":"numpy.lib._function_base_impl.meshgrid#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.meshgrid","name":"meshgrid","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5,5,5],"arg_names":[null,null,"copy","sparse","indexing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.bool",{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"meshgrid","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT1","id":-1,"name":"_ScalarT1","namespace":"numpy.lib._function_base_impl.meshgrid#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT2","id":-2,"name":"_ScalarT2","namespace":"numpy.lib._function_base_impl.meshgrid#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5],"arg_names":[null,null,"copy","sparse","indexing"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.meshgrid","name":"meshgrid","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5],"arg_names":[null,null,"copy","sparse","indexing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.bool",{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"meshgrid","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.meshgrid#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.meshgrid","name":"meshgrid","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5,5,5],"arg_names":[null,null,"copy","sparse","indexing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.bool",{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"meshgrid","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.meshgrid#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5],"arg_names":[null,null,"copy","sparse","indexing"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.meshgrid","name":"meshgrid","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5],"arg_names":[null,null,"copy","sparse","indexing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.bool",{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"meshgrid","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.meshgrid#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.meshgrid","name":"meshgrid","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5,5,5],"arg_names":[null,null,"copy","sparse","indexing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.bool",{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"meshgrid","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.meshgrid#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5],"arg_names":[null,null,"copy","sparse","indexing"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.meshgrid","name":"meshgrid","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5],"arg_names":[null,null,"copy","sparse","indexing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.bool",{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"meshgrid","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.meshgrid","name":"meshgrid","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5,5,5],"arg_names":[null,null,"copy","sparse","indexing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.bool",{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"meshgrid","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5,5,5],"arg_names":[null,null,null,"copy","sparse","indexing"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.meshgrid","name":"meshgrid","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0,0,5,5,5],"arg_names":[null,null,null,"copy","sparse","indexing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.bool",{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"meshgrid","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.meshgrid","name":"meshgrid","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,5,5,5],"arg_names":[null,null,null,"copy","sparse","indexing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.bool",{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"meshgrid","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,5,5,5],"arg_names":[null,null,null,null,"copy","sparse","indexing"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.meshgrid","name":"meshgrid","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0,0,0,5,5,5],"arg_names":[null,null,null,null,"copy","sparse","indexing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.bool",{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"meshgrid","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.meshgrid","name":"meshgrid","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,5,5,5],"arg_names":[null,null,null,null,"copy","sparse","indexing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.bool",{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"meshgrid","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[2,5,5,5],"arg_names":["xi","copy","sparse","indexing"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.meshgrid","name":"meshgrid","original_first_arg":"xi","type":{".class":"CallableType","arg_kinds":[2,5,5,5],"arg_names":["xi","copy","sparse","indexing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.bool",{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"meshgrid","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.meshgrid","name":"meshgrid","setter_type":null,"type":{".class":"CallableType","arg_kinds":[2,5,5,5],"arg_names":["xi","copy","sparse","indexing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.bool",{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"meshgrid","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[5,5,5],"arg_names":["copy","sparse","indexing"],"arg_types":["builtins.bool","builtins.bool",{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"meshgrid","ret_type":{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":[null,"copy","sparse","indexing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.bool",{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"meshgrid","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.meshgrid#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":[null,"copy","sparse","indexing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.bool",{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"meshgrid","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,5,5,5],"arg_names":[null,null,"copy","sparse","indexing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.bool",{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"meshgrid","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT1","id":-1,"name":"_ScalarT1","namespace":"numpy.lib._function_base_impl.meshgrid#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT2","id":-2,"name":"_ScalarT2","namespace":"numpy.lib._function_base_impl.meshgrid#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,5,5,5],"arg_names":[null,null,"copy","sparse","indexing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.bool",{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"meshgrid","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.meshgrid#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,5,5,5],"arg_names":[null,null,"copy","sparse","indexing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.bool",{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"meshgrid","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.meshgrid#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,5,5,5],"arg_names":[null,null,"copy","sparse","indexing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.bool",{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"meshgrid","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,5,5,5],"arg_names":[null,null,null,"copy","sparse","indexing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.bool",{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"meshgrid","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,5,5,5],"arg_names":[null,null,null,null,"copy","sparse","indexing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.bool",{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"meshgrid","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[2,5,5,5],"arg_names":["xi","copy","sparse","indexing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.bool",{".class":"AnyType","missing_import_name":"numpy.lib._function_base_impl.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"meshgrid","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"object_":{".class":"SymbolTableNode","cross_ref":"numpy.object_","kind":"Gdef","module_hidden":true,"module_public":false},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false},"percentile":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._function_base_impl.percentile","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.percentile","name":"percentile","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.percentile","name":"percentile","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.percentile","name":"percentile","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.percentile","name":"percentile","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.percentile","name":"percentile","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.percentile","name":"percentile","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.percentile","name":"percentile","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.percentile","name":"percentile","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.percentile","name":"percentile","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.percentile","name":"percentile","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.percentile","name":"percentile","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.percentile","name":"percentile","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.percentile","name":"percentile","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.percentile","name":"percentile","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.percentile","name":"percentile","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.percentile","name":"percentile","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.percentile","name":"percentile","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.percentile","name":"percentile","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.percentile","name":"percentile","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.percentile","name":"percentile","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.percentile","name":"percentile","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.percentile","name":"percentile","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.percentile","name":"percentile","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.percentile#11","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.percentile#11","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.percentile#11","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.percentile","name":"percentile","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.percentile#11","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.percentile#11","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.percentile#11","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,3,5,5,5,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.percentile","name":"percentile","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,3,5,5,5,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.percentile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.percentile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.percentile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.percentile","name":"percentile","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,3,5,5,5,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.percentile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.percentile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.percentile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.percentile#11","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.percentile#11","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.percentile#11","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,3,5,5,5,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.percentile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"percentile","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.percentile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.percentile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"piecewise":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._function_base_impl.piecewise","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,2,4],"arg_names":["x","condlist","funclist","args","kw"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.piecewise","name":"piecewise","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,0,2,4],"arg_names":["x","condlist","funclist","args","kw"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.piecewise#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"builtins.object"],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"piecewise","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.piecewise#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.piecewise","name":"piecewise","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,2,4],"arg_names":["x","condlist","funclist","args","kw"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.piecewise#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"builtins.object"],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"piecewise","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.piecewise#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,2,4],"arg_names":["x","condlist","funclist","args","kw"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.piecewise","name":"piecewise","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,0,2,4],"arg_names":["x","condlist","funclist","args","kw"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},"builtins.object"],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"piecewise","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.piecewise","name":"piecewise","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,2,4],"arg_names":["x","condlist","funclist","args","kw"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},"builtins.object"],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"piecewise","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,2,4],"arg_names":["x","condlist","funclist","args","kw"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.piecewise#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"builtins.object"],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"piecewise","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.piecewise#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,2,4],"arg_names":["x","condlist","funclist","args","kw"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},"builtins.object"],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"piecewise","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"place":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["arr","mask","vals"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._function_base_impl.place","name":"place","original_first_arg":"arr","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["arr","mask","vals"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"place","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"quantile":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._function_base_impl.quantile","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.quantile","name":"quantile","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.quantile","name":"quantile","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.quantile","name":"quantile","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.quantile","name":"quantile","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.quantile","name":"quantile","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.quantile","name":"quantile","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.quantile","name":"quantile","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.quantile","name":"quantile","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.quantile","name":"quantile","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.quantile","name":"quantile","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.quantile","name":"quantile","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.quantile","name":"quantile","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.quantile","name":"quantile","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.quantile","name":"quantile","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.quantile","name":"quantile","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.quantile","name":"quantile","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.quantile","name":"quantile","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.quantile","name":"quantile","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.quantile","name":"quantile","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.quantile","name":"quantile","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.quantile","name":"quantile","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.quantile","name":"quantile","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.quantile","name":"quantile","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.quantile#11","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.quantile#11","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.quantile#11","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.quantile","name":"quantile","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.quantile#11","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.quantile#11","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.quantile#11","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,3,5,5,5,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.quantile","name":"quantile","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,3,5,5,5,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.quantile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.quantile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.quantile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.quantile","name":"quantile","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,3,5,5,5,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.quantile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.quantile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.quantile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.quantile#11","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.quantile#11","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.quantile#11","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,3,5,5,5,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.quantile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"quantile","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.quantile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.quantile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"rot90":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._function_base_impl.rot90","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["m","k","axes"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.rot90","name":"rot90","original_first_arg":"m","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["m","k","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int",{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rot90","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.rot90#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.rot90","name":"rot90","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["m","k","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int",{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rot90","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.rot90#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["m","k","axes"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.rot90","name":"rot90","original_first_arg":"m","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["m","k","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int",{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rot90","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.rot90","name":"rot90","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["m","k","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int",{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rot90","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["m","k","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int",{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rot90","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._function_base_impl.rot90#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["m","k","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int",{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rot90","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"select":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["condlist","choicelist","default"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._function_base_impl.select","name":"select","original_first_arg":"condlist","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["condlist","choicelist","default"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"select","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"sinc":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._function_base_impl.sinc","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.sinc","name":"sinc","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sinc","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.sinc","name":"sinc","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sinc","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.sinc","name":"sinc","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sinc","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.sinc","name":"sinc","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sinc","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.sinc","name":"sinc","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sinc","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.sinc","name":"sinc","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sinc","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.sinc","name":"sinc","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sinc","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.sinc","name":"sinc","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sinc","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sinc","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sinc","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sinc","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sinc","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"sort_complex":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._function_base_impl.sort_complex","name":"sort_complex","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sort_complex","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"timedelta64":{".class":"SymbolTableNode","cross_ref":"numpy.timedelta64","kind":"Gdef","module_hidden":true,"module_public":false},"trapezoid":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._function_base_impl.trapezoid","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["y","x","dx","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.trapezoid","name":"trapezoid","original_first_arg":"y","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["y","x","dx","axis"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.float","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trapezoid","ret_type":"numpy.float64","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.trapezoid","name":"trapezoid","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["y","x","dx","axis"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.float","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trapezoid","ret_type":"numpy.float64","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["y","x","dx","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.trapezoid","name":"trapezoid","original_first_arg":"y","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["y","x","dx","axis"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.float","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trapezoid","ret_type":"numpy.complex128","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.trapezoid","name":"trapezoid","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["y","x","dx","axis"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.float","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trapezoid","ret_type":"numpy.complex128","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["y","x","dx","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.trapezoid","name":"trapezoid","original_first_arg":"y","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["y","x","dx","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.float","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trapezoid","ret_type":{".class":"UnionType","items":["numpy.float64",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.trapezoid","name":"trapezoid","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["y","x","dx","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.float","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trapezoid","ret_type":{".class":"UnionType","items":["numpy.float64",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["y","x","dx","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.trapezoid","name":"trapezoid","original_first_arg":"y","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["y","x","dx","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.float","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trapezoid","ret_type":{".class":"UnionType","items":["builtins.float",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.trapezoid","name":"trapezoid","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["y","x","dx","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.float","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trapezoid","ret_type":{".class":"UnionType","items":["builtins.float",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["y","x","dx","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.trapezoid","name":"trapezoid","original_first_arg":"y","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["y","x","dx","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.float","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trapezoid","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT_fm","id":-1,"name":"_ScalarT_fm","namespace":"numpy.lib._function_base_impl.trapezoid#4","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"}],"uses_pep604_syntax":true},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT_fm","id":-1,"name":"_ScalarT_fm","namespace":"numpy.lib._function_base_impl.trapezoid#4","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"}],"uses_pep604_syntax":true},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.trapezoid","name":"trapezoid","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["y","x","dx","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.float","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trapezoid","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT_fm","id":-1,"name":"_ScalarT_fm","namespace":"numpy.lib._function_base_impl.trapezoid#4","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"}],"uses_pep604_syntax":true},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT_fm","id":-1,"name":"_ScalarT_fm","namespace":"numpy.lib._function_base_impl.trapezoid#4","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"}],"uses_pep604_syntax":true},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["y","x","dx","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.trapezoid","name":"trapezoid","original_first_arg":"y","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["y","x","dx","axis"],"arg_types":[{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._function_base_impl.trapezoid#5","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.lib._function_base_impl._SupportsRMulFloat"}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._function_base_impl.trapezoid#5","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.lib._function_base_impl._SupportsRMulFloat"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._function_base_impl.trapezoid#5","upper_bound":"builtins.object","values":[],"variance":0}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.float","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trapezoid","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._function_base_impl.trapezoid#5","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._function_base_impl.trapezoid#5","upper_bound":"builtins.object","values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.trapezoid","name":"trapezoid","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["y","x","dx","axis"],"arg_types":[{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._function_base_impl.trapezoid#5","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.lib._function_base_impl._SupportsRMulFloat"}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._function_base_impl.trapezoid#5","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.lib._function_base_impl._SupportsRMulFloat"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._function_base_impl.trapezoid#5","upper_bound":"builtins.object","values":[],"variance":0}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.float","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trapezoid","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._function_base_impl.trapezoid#5","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._function_base_impl.trapezoid#5","upper_bound":"builtins.object","values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["y","x","dx","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.trapezoid","name":"trapezoid","original_first_arg":"y","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["y","x","dx","axis"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.float","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trapezoid","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.trapezoid","name":"trapezoid","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["y","x","dx","axis"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.float","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trapezoid","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["y","x","dx","axis"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.float","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trapezoid","ret_type":"numpy.float64","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["y","x","dx","axis"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.float","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trapezoid","ret_type":"numpy.complex128","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["y","x","dx","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.float","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trapezoid","ret_type":{".class":"UnionType","items":["numpy.float64",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["y","x","dx","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.float","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trapezoid","ret_type":{".class":"UnionType","items":["builtins.float",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["y","x","dx","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.float","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trapezoid","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT_fm","id":-1,"name":"_ScalarT_fm","namespace":"numpy.lib._function_base_impl.trapezoid#4","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"}],"uses_pep604_syntax":true},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ScalarT_fm","id":-1,"name":"_ScalarT_fm","namespace":"numpy.lib._function_base_impl.trapezoid#4","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"}],"uses_pep604_syntax":true},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["y","x","dx","axis"],"arg_types":[{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._function_base_impl.trapezoid#5","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.lib._function_base_impl._SupportsRMulFloat"}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._function_base_impl.trapezoid#5","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.lib._function_base_impl._SupportsRMulFloat"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._function_base_impl.trapezoid#5","upper_bound":"builtins.object","values":[],"variance":0}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.float","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trapezoid","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._function_base_impl.trapezoid#5","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._function_base_impl.trapezoid#5","upper_bound":"builtins.object","values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["y","x","dx","axis"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.float","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trapezoid","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"trapz":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["y","x","dx","axis"],"dataclass_transform_spec":null,"deprecated":"function numpy.lib._function_base_impl.trapz is deprecated: Use 'trapezoid' instead","flags":["is_decorated"],"fullname":"numpy.lib._function_base_impl.trapz","name":"trapz","original_first_arg":"y","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["y","x","dx","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.float","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trapz","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.trapz","name":"trapz","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["y","x","dx","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.float","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trapz","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"trim_zeros":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["filt","trim","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._function_base_impl.trim_zeros","name":"trim_zeros","original_first_arg":"filt","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["filt","trim","axis"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._function_base_impl.trim_zeros","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.lib._function_base_impl._TrimZerosSequence"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"f"},{".class":"LiteralType","fallback":"builtins.str","value":"b"},{".class":"LiteralType","fallback":"builtins.str","value":"fb"},{".class":"LiteralType","fallback":"builtins.str","value":"bf"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trim_zeros","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._function_base_impl.trim_zeros","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._function_base_impl.trim_zeros","upper_bound":"builtins.object","values":[],"variance":0}]}}},"type_check_only":{".class":"SymbolTableNode","cross_ref":"typing.type_check_only","kind":"Gdef","module_hidden":true,"module_public":false},"unwrap":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._function_base_impl.unwrap","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,5],"arg_names":["p","discont","axis","period"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.unwrap","name":"unwrap","original_first_arg":"p","type":{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["p","discont","axis","period"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int","builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unwrap","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.unwrap","name":"unwrap","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["p","discont","axis","period"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int","builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unwrap","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,5],"arg_names":["p","discont","axis","period"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._function_base_impl.unwrap","name":"unwrap","original_first_arg":"p","type":{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["p","discont","axis","period"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int","builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unwrap","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._function_base_impl.unwrap","name":"unwrap","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["p","discont","axis","period"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int","builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unwrap","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["p","discont","axis","period"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int","builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unwrap","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["p","discont","axis","period"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int","builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unwrap","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"vectorize":{".class":"SymbolTableNode","cross_ref":"numpy.vectorize","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_function_base_impl.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_function_base_impl.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_function_base_impl.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..d3d86e5bd6d5d0c3e9162ab2e67c04f3bff31ab2 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_function_base_impl.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[36,2,37,38,3,17,18,20,1,1,1,1,1],"dep_prios":[5,5,5,5,5,5,5,5,5,30,30,30,30],"dependencies":["numpy._core.multiarray","collections.abc","numpy._globals","numpy._typing","typing","_typeshed","typing_extensions","numpy","builtins","_frozen_importlib","abc","datetime","numpy._typing._nested_sequence"],"hash":"ef3dd5c398588244ec4bbed996c690f424a9bd95","id":"numpy.lib._function_base_impl","ignore_all":true,"interface_hash":"09dc9205113516eebb4f8da7072c15ad9b70c48c","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_function_base_impl.pyi","plugin_data":null,"size":29569,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_histograms_impl.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_histograms_impl.data.json new file mode 100644 index 0000000000000000000000000000000000000000..c9321babddb0f3a68d43fa8498a11295fa250cac --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_histograms_impl.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.lib._histograms_impl","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"L":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef","module_hidden":true,"module_public":false},"SupportsIndex":{".class":"SymbolTableNode","cross_ref":"typing.SupportsIndex","kind":"Gdef","module_hidden":true,"module_public":false},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.lib._histograms_impl.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._histograms_impl.TypeAlias","source_any":null,"type_of_any":3}}},"_BinKind":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.lib._histograms_impl._BinKind","name":"_BinKind","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._histograms_impl.TypeAlias","source_any":null,"type_of_any":3}}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib._histograms_impl.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._histograms_impl.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._histograms_impl.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._histograms_impl.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._histograms_impl.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._histograms_impl.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._histograms_impl.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"histogram":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["a","bins","range","density","weights"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._histograms_impl.histogram","name":"histogram","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","bins","range","density","weights"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._histograms_impl.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TupleType","implicit":false,"items":["builtins.float","builtins.float"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"histogram_bin_edges":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["a","bins","range","weights"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._histograms_impl.histogram_bin_edges","name":"histogram_bin_edges","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","bins","range","weights"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._histograms_impl.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TupleType","implicit":false,"items":["builtins.float","builtins.float"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram_bin_edges","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"histogramdd":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["sample","bins","range","density","weights"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._histograms_impl.histogramdd","name":"histogramdd","original_first_arg":"sample","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["sample","bins","range","density","weights"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.float","builtins.float"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogramdd","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_histograms_impl.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_histograms_impl.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_histograms_impl.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..38d2d826e578933d734be5ea8d5c099419e6bdfd --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_histograms_impl.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,11,2,1,1,1],"dep_prios":[5,5,5,5,30,30],"dependencies":["collections.abc","numpy._typing","typing","builtins","_frozen_importlib","abc"],"hash":"fde69ddf2b8d7ae3cfcd936cb926d0c9323a1623","id":"numpy.lib._histograms_impl","ignore_all":true,"interface_hash":"e38f5a497b505d6cbc2b93854f81a18dcf5d5fb4","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_histograms_impl.pyi","plugin_data":null,"size":1111,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_index_tricks_impl.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_index_tricks_impl.data.json new file mode 100644 index 0000000000000000000000000000000000000000..28f734b0c930d18ed92841252405641baf41f444 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_index_tricks_impl.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.lib._index_tricks_impl","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"AxisConcatenator":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.lib._index_tricks_impl.AxisConcatenator","name":"AxisConcatenator","type_vars":[{".class":"TypeVarType","default":{".class":"LiteralType","fallback":"builtins.int","value":0},"fullname":"numpy.lib._index_tricks_impl._AxisT_co","id":1,"name":"_AxisT_co","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"LiteralType","fallback":"builtins.bool","value":false},"fullname":"numpy.lib._index_tricks_impl._MatrixT_co","id":2,"name":"_MatrixT_co","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator","upper_bound":"builtins.bool","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"LiteralType","fallback":"builtins.int","value":1},"fullname":"numpy.lib._index_tricks_impl._NDMinT_co","id":3,"name":"_NDMinT_co","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"LiteralType","fallback":"builtins.int","value":-1},"fullname":"numpy.lib._index_tricks_impl._Trans1DT_co","id":4,"name":"_Trans1DT_co","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator","upper_bound":"builtins.int","values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.lib._index_tricks_impl.AxisConcatenator","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.lib._index_tricks_impl","mro":["numpy.lib._index_tricks_impl.AxisConcatenator","builtins.object"],"names":{".class":"SymbolTable","__getitem__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._index_tricks_impl.AxisConcatenator.__getitem__","name":"__getitem__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"LiteralType","fallback":"builtins.int","value":0},"fullname":"numpy.lib._index_tricks_impl._AxisT_co","id":1,"name":"_AxisT_co","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"LiteralType","fallback":"builtins.bool","value":false},"fullname":"numpy.lib._index_tricks_impl._MatrixT_co","id":2,"name":"_MatrixT_co","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator","upper_bound":"builtins.bool","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"LiteralType","fallback":"builtins.int","value":1},"fullname":"numpy.lib._index_tricks_impl._NDMinT_co","id":3,"name":"_NDMinT_co","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"LiteralType","fallback":"builtins.int","value":-1},"fullname":"numpy.lib._index_tricks_impl._Trans1DT_co","id":4,"name":"_Trans1DT_co","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.AxisConcatenator"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of AxisConcatenator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":[null,"axis","matrix","ndmin","trans1d"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._index_tricks_impl.AxisConcatenator.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":[null,"axis","matrix","ndmin","trans1d"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"LiteralType","fallback":"builtins.int","value":0},"fullname":"numpy.lib._index_tricks_impl._AxisT_co","id":1,"name":"_AxisT_co","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"LiteralType","fallback":"builtins.bool","value":false},"fullname":"numpy.lib._index_tricks_impl._MatrixT_co","id":2,"name":"_MatrixT_co","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator","upper_bound":"builtins.bool","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"LiteralType","fallback":"builtins.int","value":1},"fullname":"numpy.lib._index_tricks_impl._NDMinT_co","id":3,"name":"_NDMinT_co","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"LiteralType","fallback":"builtins.int","value":-1},"fullname":"numpy.lib._index_tricks_impl._Trans1DT_co","id":4,"name":"_Trans1DT_co","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.AxisConcatenator"},{".class":"TypeVarType","default":{".class":"LiteralType","fallback":"builtins.int","value":0},"fullname":"numpy.lib._index_tricks_impl._AxisT_co","id":1,"name":"_AxisT_co","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"LiteralType","fallback":"builtins.bool","value":false},"fullname":"numpy.lib._index_tricks_impl._MatrixT_co","id":2,"name":"_MatrixT_co","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator","upper_bound":"builtins.bool","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"LiteralType","fallback":"builtins.int","value":1},"fullname":"numpy.lib._index_tricks_impl._NDMinT_co","id":3,"name":"_NDMinT_co","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"LiteralType","fallback":"builtins.int","value":-1},"fullname":"numpy.lib._index_tricks_impl._Trans1DT_co","id":4,"name":"_Trans1DT_co","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator","upper_bound":"builtins.int","values":[],"variance":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of AxisConcatenator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__len__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._index_tricks_impl.AxisConcatenator.__len__","name":"__len__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"LiteralType","fallback":"builtins.int","value":0},"fullname":"numpy.lib._index_tricks_impl._AxisT_co","id":1,"name":"_AxisT_co","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"LiteralType","fallback":"builtins.bool","value":false},"fullname":"numpy.lib._index_tricks_impl._MatrixT_co","id":2,"name":"_MatrixT_co","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator","upper_bound":"builtins.bool","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"LiteralType","fallback":"builtins.int","value":1},"fullname":"numpy.lib._index_tricks_impl._NDMinT_co","id":3,"name":"_NDMinT_co","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"LiteralType","fallback":"builtins.int","value":-1},"fullname":"numpy.lib._index_tricks_impl._Trans1DT_co","id":4,"name":"_Trans1DT_co","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.AxisConcatenator"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__len__ of AxisConcatenator","ret_type":{".class":"LiteralType","fallback":"builtins.int","value":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"numpy.lib._index_tricks_impl.AxisConcatenator.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"axis":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._index_tricks_impl.AxisConcatenator.axis","name":"axis","setter_type":null,"type":{".class":"TypeVarType","default":{".class":"LiteralType","fallback":"builtins.int","value":0},"fullname":"numpy.lib._index_tricks_impl._AxisT_co","id":1,"name":"_AxisT_co","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator","upper_bound":"builtins.int","values":[],"variance":1}}},"concatenate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":["is_static"],"fullname":"numpy.lib._index_tricks_impl.AxisConcatenator.concatenate","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[2,5,3],"arg_names":["a","axis","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_overload","is_decorated"],"fullname":"numpy.lib._index_tricks_impl.AxisConcatenator.concatenate","name":"concatenate","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[2,5,3],"arg_names":["a","axis","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator.concatenate#0","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"concatenate of AxisConcatenator","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator.concatenate#0","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator.concatenate#0","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_staticmethod","is_ready","is_inferred"],"fullname":"numpy.lib._index_tricks_impl.AxisConcatenator.concatenate","name":"concatenate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[2,5,3],"arg_names":["a","axis","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator.concatenate#0","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"concatenate of AxisConcatenator","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator.concatenate#0","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator.concatenate#0","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[2,5,5],"arg_names":["a","axis","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_overload","is_decorated"],"fullname":"numpy.lib._index_tricks_impl.AxisConcatenator.concatenate","name":"concatenate","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[2,5,5],"arg_names":["a","axis","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"concatenate of AxisConcatenator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_staticmethod","is_ready","is_inferred"],"fullname":"numpy.lib._index_tricks_impl.AxisConcatenator.concatenate","name":"concatenate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[2,5,5],"arg_names":["a","axis","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"concatenate of AxisConcatenator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[2,5,3],"arg_names":["a","axis","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator.concatenate#0","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"concatenate of AxisConcatenator","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator.concatenate#0","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator.concatenate#0","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[2,5,5],"arg_names":["a","axis","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"concatenate of AxisConcatenator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"makemat":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready"],"fullname":"numpy.lib._index_tricks_impl.AxisConcatenator.makemat","name":"makemat","setter_type":null,"type":{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.matrix"}}}},"matrix":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._index_tricks_impl.AxisConcatenator.matrix","name":"matrix","setter_type":null,"type":{".class":"TypeVarType","default":{".class":"LiteralType","fallback":"builtins.bool","value":false},"fullname":"numpy.lib._index_tricks_impl._MatrixT_co","id":2,"name":"_MatrixT_co","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator","upper_bound":"builtins.bool","values":[],"variance":1}}},"ndmin":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._index_tricks_impl.AxisConcatenator.ndmin","name":"ndmin","setter_type":null,"type":{".class":"TypeVarType","default":{".class":"LiteralType","fallback":"builtins.int","value":1},"fullname":"numpy.lib._index_tricks_impl._NDMinT_co","id":3,"name":"_NDMinT_co","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator","upper_bound":"builtins.int","values":[],"variance":1}}},"trans1d":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._index_tricks_impl.AxisConcatenator.trans1d","name":"trans1d","setter_type":null,"type":{".class":"TypeVarType","default":{".class":"LiteralType","fallback":"builtins.int","value":-1},"fullname":"numpy.lib._index_tricks_impl._Trans1DT_co","id":4,"name":"_Trans1DT_co","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator","upper_bound":"builtins.int","values":[],"variance":1}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl.AxisConcatenator.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"LiteralType","fallback":"builtins.int","value":0},"fullname":"numpy.lib._index_tricks_impl._AxisT_co","id":1,"name":"_AxisT_co","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"LiteralType","fallback":"builtins.bool","value":false},"fullname":"numpy.lib._index_tricks_impl._MatrixT_co","id":2,"name":"_MatrixT_co","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator","upper_bound":"builtins.bool","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"LiteralType","fallback":"builtins.int","value":1},"fullname":"numpy.lib._index_tricks_impl._NDMinT_co","id":3,"name":"_NDMinT_co","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator","upper_bound":"builtins.int","values":[],"variance":1},{".class":"TypeVarType","default":{".class":"LiteralType","fallback":"builtins.int","value":-1},"fullname":"numpy.lib._index_tricks_impl._Trans1DT_co","id":4,"name":"_Trans1DT_co","namespace":"numpy.lib._index_tricks_impl.AxisConcatenator","upper_bound":"builtins.int","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.AxisConcatenator"},"values":[],"variance":0},"slots":["axis","matrix","ndmin","trans1d"],"tuple_type":null,"type_vars":["_AxisT_co","_MatrixT_co","_NDMinT_co","_Trans1DT_co"],"typeddict_type":null}},"CClass":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.int","value":-1},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.int","value":2},{".class":"LiteralType","fallback":"builtins.int","value":0}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.AxisConcatenator"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.lib._index_tricks_impl.CClass","name":"CClass","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_final"],"fullname":"numpy.lib._index_tricks_impl.CClass","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.lib._index_tricks_impl","mro":["numpy.lib._index_tricks_impl.CClass","numpy.lib._index_tricks_impl.AxisConcatenator","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._index_tricks_impl.CClass.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["numpy.lib._index_tricks_impl.CClass"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of CClass","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"numpy.lib._index_tricks_impl.CClass.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl.CClass.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.lib._index_tricks_impl.CClass","values":[],"variance":0},"slots":["axis","matrix","ndmin","trans1d"],"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ClassVar":{".class":"SymbolTableNode","cross_ref":"typing.ClassVar","kind":"Gdef","module_hidden":true,"module_public":false},"Final":{".class":"SymbolTableNode","cross_ref":"typing.Final","kind":"Gdef","module_hidden":true,"module_public":false},"Generic":{".class":"SymbolTableNode","cross_ref":"typing.Generic","kind":"Gdef","module_hidden":true,"module_public":false},"Incomplete":{".class":"SymbolTableNode","cross_ref":"_typeshed.Incomplete","kind":"Gdef","module_hidden":true,"module_public":false},"IndexExpression":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.lib._index_tricks_impl.IndexExpression","name":"IndexExpression","type_vars":[{".class":"TypeVarType","default":"builtins.bool","fullname":"numpy.lib._index_tricks_impl._BoolT_co","id":1,"name":"_BoolT_co","namespace":"numpy.lib._index_tricks_impl.IndexExpression","upper_bound":"builtins.bool","values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.lib._index_tricks_impl.IndexExpression","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.lib._index_tricks_impl","mro":["numpy.lib._index_tricks_impl.IndexExpression","builtins.object"],"names":{".class":"SymbolTable","__getitem__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._index_tricks_impl.IndexExpression.__getitem__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.lib._index_tricks_impl.IndexExpression.__getitem__","name":"__getitem__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":"builtins.bool","fullname":"numpy.lib._index_tricks_impl._BoolT_co","id":1,"name":"_BoolT_co","namespace":"numpy.lib._index_tricks_impl.IndexExpression","upper_bound":"builtins.bool","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.IndexExpression"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._TupleT","id":-1,"name":"_TupleT","namespace":"numpy.lib._index_tricks_impl.IndexExpression.__getitem__#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of IndexExpression","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._TupleT","id":-1,"name":"_TupleT","namespace":"numpy.lib._index_tricks_impl.IndexExpression.__getitem__#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._TupleT","id":-1,"name":"_TupleT","namespace":"numpy.lib._index_tricks_impl.IndexExpression.__getitem__#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._index_tricks_impl.IndexExpression.__getitem__","name":"__getitem__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":"builtins.bool","fullname":"numpy.lib._index_tricks_impl._BoolT_co","id":1,"name":"_BoolT_co","namespace":"numpy.lib._index_tricks_impl.IndexExpression","upper_bound":"builtins.bool","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.IndexExpression"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._TupleT","id":-1,"name":"_TupleT","namespace":"numpy.lib._index_tricks_impl.IndexExpression.__getitem__#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of IndexExpression","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._TupleT","id":-1,"name":"_TupleT","namespace":"numpy.lib._index_tricks_impl.IndexExpression.__getitem__#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._TupleT","id":-1,"name":"_TupleT","namespace":"numpy.lib._index_tricks_impl.IndexExpression.__getitem__#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._index_tricks_impl.IndexExpression.__getitem__","name":"__getitem__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.bool","value":true}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.IndexExpression"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._index_tricks_impl.IndexExpression.__getitem__#1","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of IndexExpression","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._index_tricks_impl.IndexExpression.__getitem__#1","upper_bound":"builtins.object","values":[],"variance":0}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._index_tricks_impl.IndexExpression.__getitem__#1","upper_bound":"builtins.object","values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._index_tricks_impl.IndexExpression.__getitem__","name":"__getitem__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.bool","value":true}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.IndexExpression"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._index_tricks_impl.IndexExpression.__getitem__#1","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of IndexExpression","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._index_tricks_impl.IndexExpression.__getitem__#1","upper_bound":"builtins.object","values":[],"variance":0}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._index_tricks_impl.IndexExpression.__getitem__#1","upper_bound":"builtins.object","values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._index_tricks_impl.IndexExpression.__getitem__","name":"__getitem__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.bool","value":false}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.IndexExpression"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._index_tricks_impl.IndexExpression.__getitem__","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of IndexExpression","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._index_tricks_impl.IndexExpression.__getitem__","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._index_tricks_impl.IndexExpression.__getitem__","upper_bound":"builtins.object","values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._index_tricks_impl.IndexExpression.__getitem__","name":"__getitem__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.bool","value":false}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.IndexExpression"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._index_tricks_impl.IndexExpression.__getitem__","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of IndexExpression","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._index_tricks_impl.IndexExpression.__getitem__","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._index_tricks_impl.IndexExpression.__getitem__","upper_bound":"builtins.object","values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":"builtins.bool","fullname":"numpy.lib._index_tricks_impl._BoolT_co","id":1,"name":"_BoolT_co","namespace":"numpy.lib._index_tricks_impl.IndexExpression","upper_bound":"builtins.bool","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.IndexExpression"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._TupleT","id":-1,"name":"_TupleT","namespace":"numpy.lib._index_tricks_impl.IndexExpression.__getitem__#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of IndexExpression","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._TupleT","id":-1,"name":"_TupleT","namespace":"numpy.lib._index_tricks_impl.IndexExpression.__getitem__#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._TupleT","id":-1,"name":"_TupleT","namespace":"numpy.lib._index_tricks_impl.IndexExpression.__getitem__#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.bool","value":true}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.IndexExpression"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._index_tricks_impl.IndexExpression.__getitem__#1","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of IndexExpression","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._index_tricks_impl.IndexExpression.__getitem__#1","upper_bound":"builtins.object","values":[],"variance":0}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._index_tricks_impl.IndexExpression.__getitem__#1","upper_bound":"builtins.object","values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.bool","value":false}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.IndexExpression"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._index_tricks_impl.IndexExpression.__getitem__","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of IndexExpression","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._index_tricks_impl.IndexExpression.__getitem__","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._index_tricks_impl.IndexExpression.__getitem__","upper_bound":"builtins.object","values":[],"variance":0}]}]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","maketuple"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._index_tricks_impl.IndexExpression.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","maketuple"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":"builtins.bool","fullname":"numpy.lib._index_tricks_impl._BoolT_co","id":1,"name":"_BoolT_co","namespace":"numpy.lib._index_tricks_impl.IndexExpression","upper_bound":"builtins.bool","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.IndexExpression"},{".class":"TypeVarType","default":"builtins.bool","fullname":"numpy.lib._index_tricks_impl._BoolT_co","id":1,"name":"_BoolT_co","namespace":"numpy.lib._index_tricks_impl.IndexExpression","upper_bound":"builtins.bool","values":[],"variance":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of IndexExpression","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"numpy.lib._index_tricks_impl.IndexExpression.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"maketuple":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._index_tricks_impl.IndexExpression.maketuple","name":"maketuple","setter_type":null,"type":{".class":"TypeVarType","default":"builtins.bool","fullname":"numpy.lib._index_tricks_impl._BoolT_co","id":1,"name":"_BoolT_co","namespace":"numpy.lib._index_tricks_impl.IndexExpression","upper_bound":"builtins.bool","values":[],"variance":1}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl.IndexExpression.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":"builtins.bool","fullname":"numpy.lib._index_tricks_impl._BoolT_co","id":1,"name":"_BoolT_co","namespace":"numpy.lib._index_tricks_impl.IndexExpression","upper_bound":"builtins.bool","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.IndexExpression"},"values":[],"variance":0},"slots":["maketuple"],"tuple_type":null,"type_vars":["_BoolT_co"],"typeddict_type":null}},"L":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"MGridClass":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.bool","value":false}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.nd_grid"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.lib._index_tricks_impl.MGridClass","name":"MGridClass","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_final"],"fullname":"numpy.lib._index_tricks_impl.MGridClass","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.lib._index_tricks_impl","mro":["numpy.lib._index_tricks_impl.MGridClass","numpy.lib._index_tricks_impl.nd_grid","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._index_tricks_impl.MGridClass.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.lib._index_tricks_impl.MGridClass"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of MGridClass","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"numpy.lib._index_tricks_impl.MGridClass.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl.MGridClass.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.lib._index_tricks_impl.MGridClass","values":[],"variance":0},"slots":["sparse"],"tuple_type":null,"type_vars":[],"typeddict_type":null}},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"OGridClass":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.bool","value":true}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.nd_grid"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.lib._index_tricks_impl.OGridClass","name":"OGridClass","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_final"],"fullname":"numpy.lib._index_tricks_impl.OGridClass","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.lib._index_tricks_impl","mro":["numpy.lib._index_tricks_impl.OGridClass","numpy.lib._index_tricks_impl.nd_grid","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._index_tricks_impl.OGridClass.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.lib._index_tricks_impl.OGridClass"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of OGridClass","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"numpy.lib._index_tricks_impl.OGridClass.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl.OGridClass.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.lib._index_tricks_impl.OGridClass","values":[],"variance":0},"slots":["sparse"],"tuple_type":null,"type_vars":[],"typeddict_type":null}},"RClass":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.int","value":0},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"LiteralType","fallback":"builtins.int","value":-1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.AxisConcatenator"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.lib._index_tricks_impl.RClass","name":"RClass","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_final"],"fullname":"numpy.lib._index_tricks_impl.RClass","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.lib._index_tricks_impl","mro":["numpy.lib._index_tricks_impl.RClass","numpy.lib._index_tricks_impl.AxisConcatenator","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._index_tricks_impl.RClass.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["numpy.lib._index_tricks_impl.RClass"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of RClass","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"numpy.lib._index_tricks_impl.RClass.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl.RClass.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.lib._index_tricks_impl.RClass","values":[],"variance":0},"slots":["axis","matrix","ndmin","trans1d"],"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Self":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.lib._index_tricks_impl.Self","name":"Self","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._index_tricks_impl.Self","source_any":null,"type_of_any":3}}},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef","module_hidden":true,"module_public":false},"SupportsIndex":{".class":"SymbolTableNode","cross_ref":"typing.SupportsIndex","kind":"Gdef","module_hidden":true,"module_public":false},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing_extensions.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"_AnyShape":{".class":"SymbolTableNode","cross_ref":"numpy._typing._shape._AnyShape","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ArrayT","name":"_ArrayT","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}},"_AxisT_co":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"LiteralType","fallback":"builtins.int","value":0},"fullname":"numpy.lib._index_tricks_impl._AxisT_co","name":"_AxisT_co","upper_bound":"builtins.int","values":[],"variance":1}},"_BoolT_co":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":"builtins.bool","fullname":"numpy.lib._index_tricks_impl._BoolT_co","name":"_BoolT_co","upper_bound":"builtins.bool","values":[],"variance":1}},"_DTypeT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._DTypeT","name":"_DTypeT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}},"_FiniteNestedSequence":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._FiniteNestedSequence","kind":"Gdef","module_hidden":true,"module_public":false},"_MatrixT_co":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"LiteralType","fallback":"builtins.bool","value":false},"fullname":"numpy.lib._index_tricks_impl._MatrixT_co","name":"_MatrixT_co","upper_bound":"builtins.bool","values":[],"variance":1}},"_NDMinT_co":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"LiteralType","fallback":"builtins.int","value":1},"fullname":"numpy.lib._index_tricks_impl._NDMinT_co","name":"_NDMinT_co","upper_bound":"builtins.int","values":[],"variance":1}},"_NestedSequence":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nested_sequence._NestedSequence","kind":"Gdef","module_hidden":true,"module_public":false},"_ScalarT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT","name":"_ScalarT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},"_ScalarT_co":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","name":"_ScalarT_co","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}},"_SupportsArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._SupportsArray","kind":"Gdef","module_hidden":true,"module_public":false},"_SupportsDType":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._SupportsDType","kind":"Gdef","module_hidden":true,"module_public":false},"_T":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._T","name":"_T","upper_bound":"builtins.object","values":[],"variance":0}},"_Trans1DT_co":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"LiteralType","fallback":"builtins.int","value":-1},"fullname":"numpy.lib._index_tricks_impl._Trans1DT_co","name":"_Trans1DT_co","upper_bound":"builtins.int","values":[],"variance":1}},"_TupleT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._TupleT","name":"_TupleT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"},"values":[],"variance":0}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib._index_tricks_impl.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._index_tricks_impl.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._index_tricks_impl.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._index_tricks_impl.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._index_tricks_impl.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._index_tricks_impl.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._index_tricks_impl.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"c_":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.lib._index_tricks_impl.c_","name":"c_","setter_type":null,"type":"numpy.lib._index_tricks_impl.CClass"}},"deprecated":{".class":"SymbolTableNode","cross_ref":"typing_extensions.deprecated","kind":"Gdef","module_hidden":true,"module_public":false},"diag_indices":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["n","ndim"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._index_tricks_impl.diag_indices","name":"diag_indices","original_first_arg":"n","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["n","ndim"],"arg_types":["builtins.int","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"diag_indices","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"diag_indices_from":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["arr"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._index_tricks_impl.diag_indices_from","name":"diag_indices_from","original_first_arg":"arr","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["arr"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"diag_indices_from","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"fill_diagonal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","val","wrap"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._index_tricks_impl.fill_diagonal","name":"fill_diagonal","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","val","wrap"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.object","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fill_diagonal","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"final":{".class":"SymbolTableNode","cross_ref":"typing.final","kind":"Gdef","module_hidden":true,"module_public":false},"index_exp":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.lib._index_tricks_impl.index_exp","name":"index_exp","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.bool","value":true}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.IndexExpression"}}},"ix_":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._index_tricks_impl.ix_","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[2],"arg_names":["args"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._index_tricks_impl.ix_","name":"ix_","original_first_arg":"args","type":{".class":"CallableType","arg_kinds":[2],"arg_names":["args"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ix_","ret_type":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy.lib._index_tricks_impl.ix_#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ndarray"}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy.lib._index_tricks_impl.ix_#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._index_tricks_impl.ix_","name":"ix_","setter_type":null,"type":{".class":"CallableType","arg_kinds":[2],"arg_names":["args"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ix_","ret_type":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy.lib._index_tricks_impl.ix_#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ndarray"}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy.lib._index_tricks_impl.ix_#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[2],"arg_names":["args"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._index_tricks_impl.ix_","name":"ix_","original_first_arg":"args","type":{".class":"CallableType","arg_kinds":[2],"arg_names":["args"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ix_","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._index_tricks_impl.ix_","name":"ix_","setter_type":null,"type":{".class":"CallableType","arg_kinds":[2],"arg_names":["args"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ix_","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[2],"arg_names":["args"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._index_tricks_impl.ix_","name":"ix_","original_first_arg":"args","type":{".class":"CallableType","arg_kinds":[2],"arg_names":["args"],"arg_types":[{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ix_","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._index_tricks_impl.ix_","name":"ix_","setter_type":null,"type":{".class":"CallableType","arg_kinds":[2],"arg_names":["args"],"arg_types":[{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ix_","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[2],"arg_names":["args"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._index_tricks_impl.ix_","name":"ix_","original_first_arg":"args","type":{".class":"CallableType","arg_kinds":[2],"arg_names":["args"],"arg_types":[{".class":"UnionType","items":["builtins.bool",{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ix_","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._index_tricks_impl.ix_","name":"ix_","setter_type":null,"type":{".class":"CallableType","arg_kinds":[2],"arg_names":["args"],"arg_types":[{".class":"UnionType","items":["builtins.bool",{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ix_","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[2],"arg_names":["args"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._index_tricks_impl.ix_","name":"ix_","original_first_arg":"args","type":{".class":"CallableType","arg_kinds":[2],"arg_names":["args"],"arg_types":[{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ix_","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._index_tricks_impl.ix_","name":"ix_","setter_type":null,"type":{".class":"CallableType","arg_kinds":[2],"arg_names":["args"],"arg_types":[{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ix_","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[2],"arg_names":["args"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._index_tricks_impl.ix_","name":"ix_","original_first_arg":"args","type":{".class":"CallableType","arg_kinds":[2],"arg_names":["args"],"arg_types":[{".class":"UnionType","items":["builtins.float",{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ix_","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._index_tricks_impl.ix_","name":"ix_","setter_type":null,"type":{".class":"CallableType","arg_kinds":[2],"arg_names":["args"],"arg_types":[{".class":"UnionType","items":["builtins.float",{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ix_","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[2],"arg_names":["args"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._index_tricks_impl.ix_","name":"ix_","original_first_arg":"args","type":{".class":"CallableType","arg_kinds":[2],"arg_names":["args"],"arg_types":[{".class":"UnionType","items":["builtins.complex",{".class":"Instance","args":["builtins.complex"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ix_","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._index_tricks_impl.ix_","name":"ix_","setter_type":null,"type":{".class":"CallableType","arg_kinds":[2],"arg_names":["args"],"arg_types":[{".class":"UnionType","items":["builtins.complex",{".class":"Instance","args":["builtins.complex"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ix_","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[2],"arg_names":["args"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ix_","ret_type":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy.lib._index_tricks_impl.ix_#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ndarray"}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy.lib._index_tricks_impl.ix_#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[2],"arg_names":["args"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ix_","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[2],"arg_names":["args"],"arg_types":[{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ix_","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[2],"arg_names":["args"],"arg_types":[{".class":"UnionType","items":["builtins.bool",{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ix_","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[2],"arg_names":["args"],"arg_types":[{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ix_","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[2],"arg_names":["args"],"arg_types":[{".class":"UnionType","items":["builtins.float",{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ix_","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[2],"arg_names":["args"],"arg_types":[{".class":"UnionType","items":["builtins.complex",{".class":"Instance","args":["builtins.complex"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ix_","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"mgrid":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.lib._index_tricks_impl.mgrid","name":"mgrid","setter_type":null,"type":"numpy.lib._index_tricks_impl.MGridClass"}},"nd_grid":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.lib._index_tricks_impl.nd_grid","name":"nd_grid","type_vars":[{".class":"TypeVarType","default":"builtins.bool","fullname":"numpy.lib._index_tricks_impl._BoolT_co","id":1,"name":"_BoolT_co","namespace":"numpy.lib._index_tricks_impl.nd_grid","upper_bound":"builtins.bool","values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.lib._index_tricks_impl.nd_grid","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.lib._index_tricks_impl","mro":["numpy.lib._index_tricks_impl.nd_grid","builtins.object"],"names":{".class":"SymbolTable","__getitem__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._index_tricks_impl.nd_grid.__getitem__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._index_tricks_impl.nd_grid.__getitem__","name":"__getitem__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.bool","value":false}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.nd_grid"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.slice"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.slice"}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of nd_grid","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._index_tricks_impl.nd_grid.__getitem__","name":"__getitem__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.bool","value":false}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.nd_grid"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.slice"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.slice"}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of nd_grid","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._index_tricks_impl.nd_grid.__getitem__","name":"__getitem__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.bool","value":true}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.nd_grid"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.slice"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.slice"}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of nd_grid","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._index_tricks_impl.nd_grid.__getitem__","name":"__getitem__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.bool","value":true}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.nd_grid"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.slice"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.slice"}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of nd_grid","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.bool","value":false}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.nd_grid"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.slice"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.slice"}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of nd_grid","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.bool","value":true}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.nd_grid"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.slice"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.slice"}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of nd_grid","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","sparse"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._index_tricks_impl.nd_grid.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","sparse"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":"builtins.bool","fullname":"numpy.lib._index_tricks_impl._BoolT_co","id":1,"name":"_BoolT_co","namespace":"numpy.lib._index_tricks_impl.nd_grid","upper_bound":"builtins.bool","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.nd_grid"},{".class":"TypeVarType","default":"builtins.bool","fullname":"numpy.lib._index_tricks_impl._BoolT_co","id":1,"name":"_BoolT_co","namespace":"numpy.lib._index_tricks_impl.nd_grid","upper_bound":"builtins.bool","values":[],"variance":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of nd_grid","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"numpy.lib._index_tricks_impl.nd_grid.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"sparse":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._index_tricks_impl.nd_grid.sparse","name":"sparse","setter_type":null,"type":{".class":"TypeVarType","default":"builtins.bool","fullname":"numpy.lib._index_tricks_impl._BoolT_co","id":1,"name":"_BoolT_co","namespace":"numpy.lib._index_tricks_impl.nd_grid","upper_bound":"builtins.bool","values":[],"variance":1}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl.nd_grid.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":"builtins.bool","fullname":"numpy.lib._index_tricks_impl._BoolT_co","id":1,"name":"_BoolT_co","namespace":"numpy.lib._index_tricks_impl.nd_grid","upper_bound":"builtins.bool","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.nd_grid"},"values":[],"variance":0},"slots":["sparse"],"tuple_type":null,"type_vars":["_BoolT_co"],"typeddict_type":null}},"ndenumerate":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.lib._index_tricks_impl.ndenumerate","name":"ndenumerate","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._index_tricks_impl.ndenumerate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.lib._index_tricks_impl.ndenumerate","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.lib._index_tricks_impl","mro":["numpy.lib._index_tricks_impl.ndenumerate","builtins.object"],"names":{".class":"SymbolTable","__iter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._index_tricks_impl.ndenumerate.__iter__","name":"__iter__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._index_tricks_impl.ndenumerate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iter__ of ndenumerate","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._index_tricks_impl.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__new__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":["is_static"],"fullname":"numpy.lib._index_tricks_impl.ndenumerate.__new__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","arr"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.lib._index_tricks_impl.ndenumerate.__new__","name":"__new__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","arr"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._index_tricks_impl.ndenumerate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"}},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of ndenumerate","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._index_tricks_impl.ndenumerate.__new__#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._index_tricks_impl.ndenumerate.__new__#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._index_tricks_impl.ndenumerate.__new__","name":"__new__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","arr"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._index_tricks_impl.ndenumerate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"}},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of ndenumerate","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._index_tricks_impl.ndenumerate.__new__#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._index_tricks_impl.ndenumerate.__new__#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","arr"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.lib._index_tricks_impl.ndenumerate.__new__","name":"__new__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","arr"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._index_tricks_impl.ndenumerate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"}},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of ndenumerate","ret_type":{".class":"Instance","args":["numpy.str_"],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._index_tricks_impl.ndenumerate.__new__","name":"__new__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","arr"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._index_tricks_impl.ndenumerate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"}},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of ndenumerate","ret_type":{".class":"Instance","args":["numpy.str_"],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","arr"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.lib._index_tricks_impl.ndenumerate.__new__","name":"__new__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","arr"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._index_tricks_impl.ndenumerate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"}},{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of ndenumerate","ret_type":{".class":"Instance","args":["numpy.bytes_"],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._index_tricks_impl.ndenumerate.__new__","name":"__new__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","arr"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._index_tricks_impl.ndenumerate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"}},{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of ndenumerate","ret_type":{".class":"Instance","args":["numpy.bytes_"],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","arr"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.lib._index_tricks_impl.ndenumerate.__new__","name":"__new__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","arr"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._index_tricks_impl.ndenumerate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"}},{".class":"UnionType","items":["builtins.bool",{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of ndenumerate","ret_type":{".class":"Instance","args":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._index_tricks_impl.ndenumerate.__new__","name":"__new__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","arr"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._index_tricks_impl.ndenumerate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"}},{".class":"UnionType","items":["builtins.bool",{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of ndenumerate","ret_type":{".class":"Instance","args":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","arr"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.lib._index_tricks_impl.ndenumerate.__new__","name":"__new__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","arr"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._index_tricks_impl.ndenumerate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"}},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of ndenumerate","ret_type":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._index_tricks_impl.ndenumerate.__new__","name":"__new__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","arr"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._index_tricks_impl.ndenumerate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"}},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of ndenumerate","ret_type":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","arr"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.lib._index_tricks_impl.ndenumerate.__new__","name":"__new__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","arr"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._index_tricks_impl.ndenumerate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"}},{".class":"UnionType","items":["builtins.float",{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of ndenumerate","ret_type":{".class":"Instance","args":["numpy.float64"],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._index_tricks_impl.ndenumerate.__new__","name":"__new__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","arr"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._index_tricks_impl.ndenumerate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"}},{".class":"UnionType","items":["builtins.float",{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of ndenumerate","ret_type":{".class":"Instance","args":["numpy.float64"],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","arr"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.lib._index_tricks_impl.ndenumerate.__new__","name":"__new__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","arr"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._index_tricks_impl.ndenumerate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"}},{".class":"UnionType","items":["builtins.complex",{".class":"Instance","args":["builtins.complex"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of ndenumerate","ret_type":{".class":"Instance","args":["numpy.complex128"],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._index_tricks_impl.ndenumerate.__new__","name":"__new__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","arr"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._index_tricks_impl.ndenumerate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"}},{".class":"UnionType","items":["builtins.complex",{".class":"Instance","args":["builtins.complex"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of ndenumerate","ret_type":{".class":"Instance","args":["numpy.complex128"],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","arr"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.lib._index_tricks_impl.ndenumerate.__new__","name":"__new__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","arr"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._index_tricks_impl.ndenumerate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"}},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of ndenumerate","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._index_tricks_impl.ndenumerate.__new__","name":"__new__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","arr"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._index_tricks_impl.ndenumerate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"}},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of ndenumerate","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","arr"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._index_tricks_impl.ndenumerate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"}},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of ndenumerate","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._index_tricks_impl.ndenumerate.__new__#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._index_tricks_impl.ndenumerate.__new__#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","arr"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._index_tricks_impl.ndenumerate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"}},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of ndenumerate","ret_type":{".class":"Instance","args":["numpy.str_"],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","arr"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._index_tricks_impl.ndenumerate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"}},{".class":"UnionType","items":["builtins.bytes",{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of ndenumerate","ret_type":{".class":"Instance","args":["numpy.bytes_"],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","arr"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._index_tricks_impl.ndenumerate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"}},{".class":"UnionType","items":["builtins.bool",{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of ndenumerate","ret_type":{".class":"Instance","args":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","arr"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._index_tricks_impl.ndenumerate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"}},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of ndenumerate","ret_type":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","arr"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._index_tricks_impl.ndenumerate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"}},{".class":"UnionType","items":["builtins.float",{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of ndenumerate","ret_type":{".class":"Instance","args":["numpy.float64"],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","arr"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._index_tricks_impl.ndenumerate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"}},{".class":"UnionType","items":["builtins.complex",{".class":"Instance","args":["builtins.complex"],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of ndenumerate","ret_type":{".class":"Instance","args":["numpy.complex128"],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","arr"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._index_tricks_impl.ndenumerate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"}},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of ndenumerate","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"__next__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._index_tricks_impl.ndenumerate.__next__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._index_tricks_impl.ndenumerate.__next__","name":"__next__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.flexible"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__next__ of ndenumerate","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._index_tricks_impl.ndenumerate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._index_tricks_impl.ndenumerate.__next__","name":"__next__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.flexible"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__next__ of ndenumerate","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._index_tricks_impl.ndenumerate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._index_tricks_impl.ndenumerate.__next__","name":"__next__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":["numpy.object_"],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__next__ of ndenumerate","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._index_tricks_impl.ndenumerate.__next__","name":"__next__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":["numpy.object_"],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__next__ of ndenumerate","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.lib._index_tricks_impl.ndenumerate.__next__","name":"__next__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._index_tricks_impl.ndenumerate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__next__ of ndenumerate","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._index_tricks_impl.ndenumerate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._index_tricks_impl.ndenumerate.__next__","name":"__next__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._index_tricks_impl.ndenumerate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__next__ of ndenumerate","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._index_tricks_impl.ndenumerate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.flexible"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__next__ of ndenumerate","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._index_tricks_impl.ndenumerate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":["numpy.object_"],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__next__ of ndenumerate","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._index_tricks_impl.ndenumerate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__next__ of ndenumerate","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._index_tricks_impl.ndenumerate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl.ndenumerate.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._index_tricks_impl.ndenumerate","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.ndenumerate"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_ScalarT_co"],"typeddict_type":null}},"ndindex":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.lib._index_tricks_impl.ndindex","name":"ndindex","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.lib._index_tricks_impl.ndindex","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.lib._index_tricks_impl","mro":["numpy.lib._index_tricks_impl.ndindex","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._index_tricks_impl.ndindex.__init__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.lib._index_tricks_impl.ndindex.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib._index_tricks_impl.ndindex",{".class":"Instance","args":["typing.SupportsIndex"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of ndindex","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._index_tricks_impl.ndindex.__init__","name":"__init__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib._index_tricks_impl.ndindex",{".class":"Instance","args":["typing.SupportsIndex"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of ndindex","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2],"arg_names":[null,"shape"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.lib._index_tricks_impl.ndindex.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2],"arg_names":[null,"shape"],"arg_types":["numpy.lib._index_tricks_impl.ndindex","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of ndindex","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._index_tricks_impl.ndindex.__init__","name":"__init__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,2],"arg_names":[null,"shape"],"arg_types":["numpy.lib._index_tricks_impl.ndindex","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of ndindex","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib._index_tricks_impl.ndindex",{".class":"Instance","args":["typing.SupportsIndex"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of ndindex","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,2],"arg_names":[null,"shape"],"arg_types":["numpy.lib._index_tricks_impl.ndindex","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of ndindex","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"__iter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._index_tricks_impl.ndindex.__iter__","name":"__iter__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["numpy.lib._index_tricks_impl.ndindex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iter__ of ndindex","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._index_tricks_impl.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__next__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._index_tricks_impl.ndindex.__next__","name":"__next__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.lib._index_tricks_impl.ndindex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__next__ of ndindex","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"ndincr":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":"function numpy.lib._index_tricks_impl.ndindex.ndincr is deprecated: Deprecated since 1.20.0.","flags":["is_decorated","is_trivial_self"],"fullname":"numpy.lib._index_tricks_impl.ndindex.ndincr","name":"ndincr","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["numpy.lib._index_tricks_impl.ndindex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ndincr of ndindex","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred"],"fullname":"numpy.lib._index_tricks_impl.ndindex.ndincr","name":"ndincr","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["numpy.lib._index_tricks_impl.ndindex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ndincr of ndindex","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._index_tricks_impl.ndindex.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.lib._index_tricks_impl.ndindex","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"ogrid":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.lib._index_tricks_impl.ogrid","name":"ogrid","setter_type":null,"type":"numpy.lib._index_tricks_impl.OGridClass"}},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false},"r_":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.lib._index_tricks_impl.r_","name":"r_","setter_type":null,"type":"numpy.lib._index_tricks_impl.RClass"}},"ravel_multi_index":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.ravel_multi_index","kind":"Gdef"},"s_":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.lib._index_tricks_impl.s_","name":"s_","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.bool","value":false}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.IndexExpression"}}},"unravel_index":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.unravel_index","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_index_tricks_impl.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_index_tricks_impl.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_index_tricks_impl.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..029d5168ef0345271d4a40db3bae56a6fc64b5e8 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_index_tricks_impl.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[9,1,10,2,5,6,8,1,1,1,1,1],"dep_prios":[5,5,5,5,5,5,10,5,30,30,30,30],"dependencies":["numpy._core.multiarray","collections.abc","numpy._typing","typing","_typeshed","typing_extensions","numpy","builtins","_frozen_importlib","abc","datetime","numpy._typing._nested_sequence"],"hash":"cfb892e44536a2d4b996341f8e98c2c450102ec3","id":"numpy.lib._index_tricks_impl","ignore_all":true,"interface_hash":"221e6f8935fd8edf1fd0c9ed9d2bad02d97d5ba2","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_index_tricks_impl.pyi","plugin_data":null,"size":6466,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_iotools.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_iotools.data.json new file mode 100644 index 0000000000000000000000000000000000000000..d82375435de5f8e0ed0308d127d924d398ab2e50 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_iotools.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.lib._iotools","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef","module_hidden":true,"module_public":false},"ClassVar":{".class":"SymbolTableNode","cross_ref":"typing.ClassVar","kind":"Gdef","module_hidden":true,"module_public":false},"ConversionWarning":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.UserWarning"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.lib._iotools.ConversionWarning","name":"ConversionWarning","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.lib._iotools.ConversionWarning","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.lib._iotools","mro":["numpy.lib._iotools.ConversionWarning","builtins.UserWarning","builtins.Warning","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._iotools.ConversionWarning.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.lib._iotools.ConversionWarning","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ConverterError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.Exception"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.lib._iotools.ConverterError","name":"ConverterError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.lib._iotools.ConverterError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.lib._iotools","mro":["numpy.lib._iotools.ConverterError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._iotools.ConverterError.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.lib._iotools.ConverterError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ConverterLockError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy.lib._iotools.ConverterError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.lib._iotools.ConverterLockError","name":"ConverterLockError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.lib._iotools.ConverterLockError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.lib._iotools","mro":["numpy.lib._iotools.ConverterLockError","numpy.lib._iotools.ConverterError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._iotools.ConverterLockError.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.lib._iotools.ConverterLockError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Final":{".class":"SymbolTableNode","cross_ref":"typing.Final","kind":"Gdef","module_hidden":true,"module_public":false},"Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef","module_hidden":true,"module_public":false},"LineSplitter":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.lib._iotools.LineSplitter","name":"LineSplitter","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.lib._iotools.LineSplitter","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.lib._iotools","mro":["numpy.lib._iotools.LineSplitter","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"line"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._iotools.LineSplitter.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"line"],"arg_types":["numpy.lib._iotools.LineSplitter",{".class":"UnionType","items":["builtins.str","builtins.bytes"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of LineSplitter","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":[null,"delimiter","comments","autostrip","encoding"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._iotools.LineSplitter.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":[null,"delimiter","comments","autostrip","encoding"],"arg_types":["numpy.lib._iotools.LineSplitter",{".class":"UnionType","items":["builtins.str","builtins.bytes","builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str","builtins.bytes"],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of LineSplitter","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"autostrip":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"method"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._iotools.LineSplitter.autostrip","name":"autostrip","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"method"],"arg_types":["numpy.lib._iotools.LineSplitter",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._iotools._T","id":-1,"name":"_T","namespace":"numpy.lib._iotools.LineSplitter.autostrip","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"autostrip of LineSplitter","ret_type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._iotools._T","id":-1,"name":"_T","namespace":"numpy.lib._iotools.LineSplitter.autostrip","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._iotools._T","id":-1,"name":"_T","namespace":"numpy.lib._iotools.LineSplitter.autostrip","upper_bound":"builtins.object","values":[],"variance":0}]}}},"comments":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._iotools.LineSplitter.comments","name":"comments","setter_type":null,"type":"builtins.str"}},"delimiter":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._iotools.LineSplitter.delimiter","name":"delimiter","setter_type":null,"type":{".class":"UnionType","items":["builtins.str","builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}}},"encoding":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._iotools.LineSplitter.encoding","name":"encoding","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._iotools.LineSplitter.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.lib._iotools.LineSplitter","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"NameValidator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.lib._iotools.NameValidator","name":"NameValidator","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.lib._iotools.NameValidator","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.lib._iotools","mro":["numpy.lib._iotools.NameValidator","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":[null,"names","defaultfmt","nbfields"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._iotools.NameValidator.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":[null,"names","defaultfmt","nbfields"],"arg_types":["numpy.lib._iotools.NameValidator",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.str",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of NameValidator","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":[null,"excludelist","deletechars","case_sensitive","replace_space"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._iotools.NameValidator.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":[null,"excludelist","deletechars","case_sensitive","replace_space"],"arg_types":["numpy.lib._iotools.NameValidator",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"upper"},{".class":"LiteralType","fallback":"builtins.str","value":"lower"},"builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of NameValidator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"case_converter":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._iotools.NameValidator.case_converter","name":"case_converter","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"defaultdeletechars":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready"],"fullname":"numpy.lib._iotools.NameValidator.defaultdeletechars","name":"defaultdeletechars","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"}}},"defaultexcludelist":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready"],"fullname":"numpy.lib._iotools.NameValidator.defaultexcludelist","name":"defaultexcludelist","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"}}},"deletechars":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._iotools.NameValidator.deletechars","name":"deletechars","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"excludelist":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._iotools.NameValidator.excludelist","name":"excludelist","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"replace_space":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._iotools.NameValidator.replace_space","name":"replace_space","setter_type":null,"type":"builtins.str"}},"validate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":[null,"names","defaultfmt","nbfields"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._iotools.NameValidator.validate","name":"validate","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":[null,"names","defaultfmt","nbfields"],"arg_types":["numpy.lib._iotools.NameValidator",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.str",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate of NameValidator","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._iotools.NameValidator.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.lib._iotools.NameValidator","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef","module_hidden":true,"module_public":false},"StringConverter":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.lib._iotools.StringConverter","name":"StringConverter","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.lib._iotools.StringConverter","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.lib._iotools","mro":["numpy.lib._iotools.StringConverter","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._iotools.StringConverter.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"value"],"arg_types":["numpy.lib._iotools.StringConverter","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of StringConverter","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":[null,"dtype_or_func","default","missing_values","locked"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._iotools.StringConverter.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":[null,"dtype_or_func","default","missing_values","locked"],"arg_types":["numpy.lib._iotools.StringConverter",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of StringConverter","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"default":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._iotools.StringConverter.default","name":"default","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"func":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._iotools.StringConverter.func","name":"func","setter_type":null,"type":{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":true}}},"iterupgrade":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._iotools.StringConverter.iterupgrade","name":"iterupgrade","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"value"],"arg_types":["numpy.lib._iotools.StringConverter",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.str"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"iterupgrade of StringConverter","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"missing_values":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._iotools.StringConverter.missing_values","name":"missing_values","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"type":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._iotools.StringConverter.type","name":"type","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"}],"uses_pep604_syntax":true}}},"update":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1],"arg_names":[null,"func","default","testing_value","missing_values","locked"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._iotools.StringConverter.update","name":"update","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":[null,"func","default","testing_value","missing_values","locked"],"arg_types":["numpy.lib._iotools.StringConverter",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"UnionType","items":["builtins.object",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"update of StringConverter","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"upgrade":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._iotools.StringConverter.upgrade","name":"upgrade","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"value"],"arg_types":["numpy.lib._iotools.StringConverter","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"upgrade of StringConverter","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"upgrade_mapper":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["cls","func","default"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"numpy.lib._iotools.StringConverter.upgrade_mapper","name":"upgrade_mapper","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["cls","func","default"],"arg_types":[{".class":"TypeType","item":"numpy.lib._iotools.StringConverter"},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"UnionType","items":["builtins.object",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"upgrade_mapper of StringConverter","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"numpy.lib._iotools.StringConverter.upgrade_mapper","name":"upgrade_mapper","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["cls","func","default"],"arg_types":[{".class":"TypeType","item":"numpy.lib._iotools.StringConverter"},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"UnionType","items":["builtins.object",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"upgrade_mapper of StringConverter","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._iotools.StringConverter.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.lib._iotools.StringConverter","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"TypedDict":{".class":"SymbolTableNode","cross_ref":"typing.TypedDict","kind":"Gdef","module_hidden":true,"module_public":false},"Unpack":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.lib._iotools.Unpack","name":"Unpack","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._iotools.Unpack","source_any":null,"type_of_any":3}}},"_T":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._iotools._T","name":"_T","upper_bound":"builtins.object","values":[],"variance":0}},"_ValidationKwargs":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.lib._iotools._ValidationKwargs","name":"_ValidationKwargs","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.lib._iotools._ValidationKwargs","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.lib._iotools","mro":["numpy.lib._iotools._ValidationKwargs","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["excludelist",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],["deletechars",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],["case_sensitive",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"upper"},{".class":"LiteralType","fallback":"builtins.str","value":"lower"},"builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],["replace_space","builtins.str"]],"readonly_keys":[],"required_keys":[]}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._iotools.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._iotools.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__docformat__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","final_value":"restructuredtext en","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.lib._iotools.__docformat__","name":"__docformat__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._iotools.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._iotools.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._iotools.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._iotools.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"easy_dtype":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,4],"arg_names":["ndtype","names","defaultfmt","validationargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._iotools.easy_dtype","name":"easy_dtype","original_first_arg":"ndtype","type":{".class":"CallableType","arg_kinds":[0,1,1,4],"arg_names":["ndtype","names","defaultfmt","validationargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str",{".class":"AnyType","missing_import_name":"numpy.lib._iotools.Unpack","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"easy_dtype","ret_type":{".class":"Instance","args":["numpy.void"],"extra_attrs":null,"type_ref":"numpy.dtype"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"flatten_dtype":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["ndtype","flatten_base"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._iotools.flatten_dtype","name":"flatten_dtype","original_first_arg":"ndtype","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["ndtype","flatten_base"],"arg_types":[{".class":"Instance","args":["numpy.void"],"extra_attrs":null,"type_ref":"numpy.dtype"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"flatten_dtype","ret_type":{".class":"TypeType","item":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"has_nested_fields":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["ndtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._iotools.has_nested_fields","name":"has_nested_fields","original_first_arg":"ndtype","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["ndtype"],"arg_types":[{".class":"Instance","args":["numpy.void"],"extra_attrs":null,"type_ref":"numpy.dtype"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"has_nested_fields","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"npt":{".class":"SymbolTableNode","cross_ref":"numpy.typing","kind":"Gdef","module_hidden":true,"module_public":false},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false},"str2bool":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._iotools.str2bool","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._iotools.str2bool","name":"str2bool","original_first_arg":"value","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["value"],"arg_types":[{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"false"},{".class":"LiteralType","fallback":"builtins.str","value":"False"},{".class":"LiteralType","fallback":"builtins.str","value":"FALSE"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"str2bool","ret_type":{".class":"LiteralType","fallback":"builtins.bool","value":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._iotools.str2bool","name":"str2bool","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["value"],"arg_types":[{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"false"},{".class":"LiteralType","fallback":"builtins.str","value":"False"},{".class":"LiteralType","fallback":"builtins.str","value":"FALSE"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"str2bool","ret_type":{".class":"LiteralType","fallback":"builtins.bool","value":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._iotools.str2bool","name":"str2bool","original_first_arg":"value","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["value"],"arg_types":[{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"true"},{".class":"LiteralType","fallback":"builtins.str","value":"True"},{".class":"LiteralType","fallback":"builtins.str","value":"TRUE"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"str2bool","ret_type":{".class":"LiteralType","fallback":"builtins.bool","value":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._iotools.str2bool","name":"str2bool","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["value"],"arg_types":[{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"true"},{".class":"LiteralType","fallback":"builtins.str","value":"True"},{".class":"LiteralType","fallback":"builtins.str","value":"TRUE"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"str2bool","ret_type":{".class":"LiteralType","fallback":"builtins.bool","value":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["value"],"arg_types":[{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"false"},{".class":"LiteralType","fallback":"builtins.str","value":"False"},{".class":"LiteralType","fallback":"builtins.str","value":"FALSE"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"str2bool","ret_type":{".class":"LiteralType","fallback":"builtins.bool","value":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["value"],"arg_types":[{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"true"},{".class":"LiteralType","fallback":"builtins.str","value":"True"},{".class":"LiteralType","fallback":"builtins.str","value":"TRUE"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"str2bool","ret_type":{".class":"LiteralType","fallback":"builtins.bool","value":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"type_check_only":{".class":"SymbolTableNode","cross_ref":"typing.type_check_only","kind":"Gdef","module_hidden":true,"module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_iotools.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_iotools.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_iotools.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..07c335dc0a567427ea5b5783a758aeab2b740fc2 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_iotools.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,15,2,14,1,1,1,1],"dep_prios":[5,10,5,10,5,30,30,30],"dependencies":["collections.abc","numpy.typing","typing","numpy","builtins","_frozen_importlib","abc","datetime"],"hash":"d8cd4507d864c89286210aa2f1017aa7346f6ae5","id":"numpy.lib._iotools","ignore_all":true,"interface_hash":"8823e8ddf5992b813b23573a97a239c914a318d5","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_iotools.pyi","plugin_data":null,"size":3393,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_nanfunctions_impl.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_nanfunctions_impl.data.json new file mode 100644 index 0000000000000000000000000000000000000000..07719b8a3d5977e770894137f6444b8350d2a828 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_nanfunctions_impl.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.lib._nanfunctions_impl","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib._nanfunctions_impl.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._nanfunctions_impl.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._nanfunctions_impl.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._nanfunctions_impl.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._nanfunctions_impl.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._nanfunctions_impl.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._nanfunctions_impl.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"amax":{".class":"SymbolTableNode","cross_ref":"numpy._core.fromnumeric.amax","kind":"Gdef","module_hidden":true,"module_public":false},"amin":{".class":"SymbolTableNode","cross_ref":"numpy._core.fromnumeric.amin","kind":"Gdef","module_hidden":true,"module_public":false},"argmax":{".class":"SymbolTableNode","cross_ref":"numpy._core.fromnumeric.argmax","kind":"Gdef","module_hidden":true,"module_public":false},"argmin":{".class":"SymbolTableNode","cross_ref":"numpy._core.fromnumeric.argmin","kind":"Gdef","module_hidden":true,"module_public":false},"cumprod":{".class":"SymbolTableNode","cross_ref":"numpy._core.fromnumeric.cumprod","kind":"Gdef","module_hidden":true,"module_public":false},"cumsum":{".class":"SymbolTableNode","cross_ref":"numpy._core.fromnumeric.cumsum","kind":"Gdef","module_hidden":true,"module_public":false},"mean":{".class":"SymbolTableNode","cross_ref":"numpy._core.fromnumeric.mean","kind":"Gdef","module_hidden":true,"module_public":false},"median":{".class":"SymbolTableNode","cross_ref":"numpy.lib._function_base_impl.median","kind":"Gdef","module_hidden":true,"module_public":false},"nanargmax":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib._nanfunctions_impl.nanargmax","name":"nanargmax","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,5],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmax#2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmax#2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmax#2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmax","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmax","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmax","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}]}}},"nanargmin":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib._nanfunctions_impl.nanargmin","name":"nanargmin","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,5],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmin#2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmin#2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmin#2","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["a","axis","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmin","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmin","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._BoolOrIntArrayT","id":-1,"name":"_BoolOrIntArrayT","namespace":"numpy._core.fromnumeric.argmin","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}]}}},"nancumprod":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib._nanfunctions_impl.nancumprod","name":"nancumprod","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.cumprod#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.cumprod#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumprod#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumprod#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumprod#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,3],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumprod","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumprod","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumprod","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"nancumsum":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib._nanfunctions_impl.nancumsum","name":"nancumsum","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.cumsum#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.cumsum#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.cumsum#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumsum#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumsum#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumsum#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,3],"arg_names":["a","axis","dtype","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumsum","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumsum","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.cumsum","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"nanmax":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib._nanfunctions_impl.nanmax","name":"nanmax","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1,1],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.amax#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.amax#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amax#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amax#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amax#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5,5,5],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amax","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amax","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amax","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"nanmean":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib._nanfunctions_impl.nanmean","name":"nanmean","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.mean#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.mean#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.mean#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,3,5,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.mean#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.mean#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.mean#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.mean#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.mean#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5,5,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.mean#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.mean#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,0,0,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.int","value":1}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.mean#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,1,5,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.mean#8","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.mean#8","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5,5,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.mean#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.mean#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["a","axis","dtype","out","keepdims","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"nanmedian":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib._nanfunctions_impl.nanmedian","name":"nanmedian","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","axis","out","overwrite_input","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","axis","out","overwrite_input","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","axis","out","overwrite_input","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","axis","out","overwrite_input","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["a","axis","out","overwrite_input","keepdims"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1],"arg_names":["a","axis","out","overwrite_input","keepdims"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.median#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.median#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.median#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5,5],"arg_names":["a","axis","out","overwrite_input","keepdims"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.median","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.median","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.median","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"nanmin":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib._nanfunctions_impl.nanmin","name":"nanmin","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1,1],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.amin#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.amin#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amin#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amin#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amin#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5,5,5],"arg_names":["a","axis","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amin","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amin","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.amin","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"nanpercentile":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib._nanfunctions_impl.nanpercentile","name":"nanpercentile","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.percentile#11","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.percentile#11","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.percentile#11","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,3,5,5,5,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.percentile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.percentile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.percentile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"nanprod":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib._nanfunctions_impl.nanprod","name":"nanprod","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int_"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.prod#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.prod#6","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5,5,5,5],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.prod#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.prod#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.prod#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.prod#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.prod#9","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,3,5,5,5],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.prod","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.prod","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.prod","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"nanquantile":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib._nanfunctions_impl.nanquantile","name":"nanquantile","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["datetime.timedelta","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.timedelta64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["datetime.date","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.datetime64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.quantile#11","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.quantile#11","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.quantile#11","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,3,5,5,5,5,5],"arg_names":["a","q","axis","out","overwrite_input","method","keepdims","weights","interpolation"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.quantile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"numpy.lib._function_base_impl._MethodKind"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.quantile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._function_base_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._function_base_impl.quantile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"nanstd":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib._nanfunctions_impl.nanstd","name":"nanstd","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.float",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},"builtins.float","builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.float",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.std#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.std#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5,5,5,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.float",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.std#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.std#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.float","builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.std#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.float","builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.std#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.std#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,3,5,5,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.std","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.float","builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.std","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.std","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"nansum":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib._nanfunctions_impl.nansum","name":"nansum","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5,5,5,5],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5,5,5,5],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.sum#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.sum#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.sum#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.sum#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,3,5,5,5],"arg_names":["a","axis","dtype","out","keepdims","initial","where"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.sum","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.sum","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.sum","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"nanvar":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib._nanfunctions_impl.nanvar","name":"nanvar","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.float",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"NoneType"},"builtins.float","builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.float",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.var#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.var#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5,5,5,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.float",{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.var#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy._core.fromnumeric.var#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.float","builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.var#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.float","builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.var#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.var#5","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,3,5,5,5,5,5],"arg_names":["a","axis","dtype","out","ddof","keepdims","where","mean","correction"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.var","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"builtins.float","builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float","numpy._globals._NoValueType"],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.var","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy._core.fromnumeric._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy._core.fromnumeric.var","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"percentile":{".class":"SymbolTableNode","cross_ref":"numpy.lib._function_base_impl.percentile","kind":"Gdef","module_hidden":true,"module_public":false},"prod":{".class":"SymbolTableNode","cross_ref":"numpy._core.fromnumeric.prod","kind":"Gdef","module_hidden":true,"module_public":false},"quantile":{".class":"SymbolTableNode","cross_ref":"numpy.lib._function_base_impl.quantile","kind":"Gdef","module_hidden":true,"module_public":false},"std":{".class":"SymbolTableNode","cross_ref":"numpy._core.fromnumeric.std","kind":"Gdef","module_hidden":true,"module_public":false},"sum":{".class":"SymbolTableNode","cross_ref":"numpy._core.fromnumeric.sum","kind":"Gdef","module_hidden":true,"module_public":false},"var":{".class":"SymbolTableNode","cross_ref":"numpy._core.fromnumeric.var","kind":"Gdef","module_hidden":true,"module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_nanfunctions_impl.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_nanfunctions_impl.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_nanfunctions_impl.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..2deb8f59e0a458f6c747d3271055fb5bfeff3cb7 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_nanfunctions_impl.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,14,1,1,1,1,1,1,1,1,1],"dep_prios":[5,5,5,30,30,30,30,30,30,30,30],"dependencies":["numpy._core.fromnumeric","numpy.lib._function_base_impl","builtins","_frozen_importlib","abc","datetime","numpy._core","numpy._globals","numpy._typing","numpy._typing._nbit_base","typing"],"hash":"ab2c4c47ae604ce89730586d07e46ac128837d24","id":"numpy.lib._nanfunctions_impl","ignore_all":true,"interface_hash":"4266133b9f7ec0204943afc194da27472335a9e4","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_nanfunctions_impl.pyi","plugin_data":null,"size":833,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_npyio_impl.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_npyio_impl.data.json new file mode 100644 index 0000000000000000000000000000000000000000..6aedd7c2c2552752127538e8a896e5fef329541c --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_npyio_impl.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.lib._npyio_impl","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"BagObj":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.lib._npyio_impl.BagObj","name":"BagObj","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._npyio_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._npyio_impl.BagObj","upper_bound":"builtins.object","values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.lib._npyio_impl.BagObj","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.lib._npyio_impl","mro":["numpy.lib._npyio_impl.BagObj","builtins.object"],"names":{".class":"SymbolTable","__dir__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._npyio_impl.BagObj.__dir__","name":"__dir__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._npyio_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._npyio_impl.BagObj","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._npyio_impl.BagObj"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__dir__ of BagObj","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__getattribute__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._npyio_impl.BagObj.__getattribute__","name":"__getattribute__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._npyio_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._npyio_impl.BagObj","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._npyio_impl.BagObj"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getattribute__ of BagObj","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._npyio_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._npyio_impl.BagObj","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._npyio_impl.BagObj.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"obj"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._npyio_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._npyio_impl.BagObj","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._npyio_impl.BagObj"},{".class":"Instance","args":["builtins.str",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._npyio_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._npyio_impl.BagObj","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"_typeshed.SupportsKeysAndGetItem"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of BagObj","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._npyio_impl.BagObj.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._npyio_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._npyio_impl.BagObj","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._npyio_impl.BagObj"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_T_co"],"typeddict_type":null}},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef","module_hidden":true,"module_public":false},"ClassVar":{".class":"SymbolTableNode","cross_ref":"typing.ClassVar","kind":"Gdef","module_hidden":true,"module_public":false},"Collection":{".class":"SymbolTableNode","cross_ref":"typing.Collection","kind":"Gdef","module_hidden":true,"module_public":false},"DTypeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like.DTypeLike","kind":"Gdef","module_hidden":true,"module_public":false},"DataSource":{".class":"SymbolTableNode","cross_ref":"numpy.lib._datasource.DataSource","kind":"Gdef","module_public":false},"Generic":{".class":"SymbolTableNode","cross_ref":"typing.Generic","kind":"Gdef","module_hidden":true,"module_public":false},"IO":{".class":"SymbolTableNode","cross_ref":"typing.IO","kind":"Gdef","module_hidden":true,"module_public":false},"Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef","module_hidden":true,"module_public":false},"Iterator":{".class":"SymbolTableNode","cross_ref":"typing.Iterator","kind":"Gdef","module_hidden":true,"module_public":false},"L":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"Mapping":{".class":"SymbolTableNode","cross_ref":"typing.Mapping","kind":"Gdef","module_hidden":true,"module_public":false},"MaskedRecords":{".class":"SymbolTableNode","cross_ref":"numpy.ma.mrecords.MaskedRecords","kind":"Gdef","module_hidden":true,"module_public":false},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"NpzFile":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Mapping"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.lib._npyio_impl.NpzFile","name":"NpzFile","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"fullname":"numpy.lib._npyio_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._npyio_impl.NpzFile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.lib._npyio_impl.NpzFile","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.lib._npyio_impl","mro":["numpy.lib._npyio_impl.NpzFile","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","_MAX_REPR_ARRAY_COUNT":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready","has_explicit_value"],"fullname":"numpy.lib._npyio_impl.NpzFile._MAX_REPR_ARRAY_COUNT","name":"_MAX_REPR_ARRAY_COUNT","setter_type":null,"type":"builtins.int"}},"__del__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._npyio_impl.NpzFile.__del__","name":"__del__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"fullname":"numpy.lib._npyio_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._npyio_impl.NpzFile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._npyio_impl.NpzFile"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__del__ of NpzFile","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__enter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._npyio_impl.NpzFile.__enter__","name":"__enter__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"fullname":"numpy.lib._npyio_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._npyio_impl.NpzFile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._npyio_impl.NpzFile"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__enter__ of NpzFile","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__exit__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":[null,null,null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._npyio_impl.NpzFile.__exit__","name":"__exit__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,null,null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"fullname":"numpy.lib._npyio_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._npyio_impl.NpzFile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._npyio_impl.NpzFile"},{".class":"UnionType","items":[{".class":"TypeType","item":"builtins.BaseException"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.BaseException",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["types.TracebackType",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__exit__ of NpzFile","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__getitem__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated","is_trivial_self"],"fullname":"numpy.lib._npyio_impl.NpzFile.__getitem__","name":"__getitem__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"fullname":"numpy.lib._npyio_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._npyio_impl.NpzFile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._npyio_impl.NpzFile"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of NpzFile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred"],"fullname":"numpy.lib._npyio_impl.NpzFile.__getitem__","name":"__getitem__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"fullname":"numpy.lib._npyio_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._npyio_impl.NpzFile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._npyio_impl.NpzFile"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of NpzFile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,5],"arg_names":[null,"fid","own_fid","allow_pickle","pickle_kwargs","max_header_size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._npyio_impl.NpzFile.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,5],"arg_names":[null,"fid","own_fid","allow_pickle","pickle_kwargs","max_header_size"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"fullname":"numpy.lib._npyio_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._npyio_impl.NpzFile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._npyio_impl.NpzFile"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.IO"},"builtins.bool","builtins.bool",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","builtins.object"],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of NpzFile","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__iter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated","is_trivial_self"],"fullname":"numpy.lib._npyio_impl.NpzFile.__iter__","name":"__iter__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"fullname":"numpy.lib._npyio_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._npyio_impl.NpzFile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._npyio_impl.NpzFile"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iter__ of NpzFile","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred"],"fullname":"numpy.lib._npyio_impl.NpzFile.__iter__","name":"__iter__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"fullname":"numpy.lib._npyio_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._npyio_impl.NpzFile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._npyio_impl.NpzFile"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iter__ of NpzFile","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__len__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated","is_trivial_self"],"fullname":"numpy.lib._npyio_impl.NpzFile.__len__","name":"__len__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"fullname":"numpy.lib._npyio_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._npyio_impl.NpzFile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._npyio_impl.NpzFile"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__len__ of NpzFile","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred"],"fullname":"numpy.lib._npyio_impl.NpzFile.__len__","name":"__len__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"fullname":"numpy.lib._npyio_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._npyio_impl.NpzFile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._npyio_impl.NpzFile"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__len__ of NpzFile","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"allow_pickle":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._npyio_impl.NpzFile.allow_pickle","name":"allow_pickle","setter_type":null,"type":"builtins.bool"}},"close":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._npyio_impl.NpzFile.close","name":"close","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"fullname":"numpy.lib._npyio_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._npyio_impl.NpzFile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._npyio_impl.NpzFile"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"close of NpzFile","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"f":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._npyio_impl.NpzFile.f","name":"f","setter_type":null,"type":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"fullname":"numpy.lib._npyio_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._npyio_impl.NpzFile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._npyio_impl.NpzFile"}],"extra_attrs":null,"type_ref":"numpy.lib._npyio_impl.BagObj"}}},"fid":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._npyio_impl.NpzFile.fid","name":"fid","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.IO"},{".class":"NoneType"}],"uses_pep604_syntax":true}}},"files":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._npyio_impl.NpzFile.files","name":"files","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"pickle_kwargs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._npyio_impl.NpzFile.pickle_kwargs","name":"pickle_kwargs","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"NoneType"}],"uses_pep604_syntax":true}}},"zip":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._npyio_impl.NpzFile.zip","name":"zip","setter_type":null,"type":"zipfile.ZipFile"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._npyio_impl.NpzFile.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"fullname":"numpy.lib._npyio_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._npyio_impl.NpzFile","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._npyio_impl.NpzFile"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_ScalarT_co"],"typeddict_type":null}},"Pattern":{".class":"SymbolTableNode","cross_ref":"re.Pattern","kind":"Gdef","module_hidden":true,"module_public":false},"Protocol":{".class":"SymbolTableNode","cross_ref":"typing.Protocol","kind":"Gdef","module_hidden":true,"module_public":false},"Self":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.lib._npyio_impl.Self","name":"Self","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.Self","source_any":null,"type_of_any":3}}},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef","module_hidden":true,"module_public":false},"StrOrBytesPath":{".class":"SymbolTableNode","cross_ref":"_typeshed.StrOrBytesPath","kind":"Gdef","module_hidden":true,"module_public":false},"StrPath":{".class":"SymbolTableNode","cross_ref":"_typeshed.StrPath","kind":"Gdef","module_hidden":true,"module_public":false},"SupportsKeysAndGetItem":{".class":"SymbolTableNode","cross_ref":"_typeshed.SupportsKeysAndGetItem","kind":"Gdef","module_hidden":true,"module_public":false},"SupportsRead":{".class":"SymbolTableNode","cross_ref":"_typeshed.SupportsRead","kind":"Gdef","module_hidden":true,"module_public":false},"SupportsWrite":{".class":"SymbolTableNode","cross_ref":"_typeshed.SupportsWrite","kind":"Gdef","module_hidden":true,"module_public":false},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.lib._npyio_impl.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3}}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing_extensions.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"_DTypeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._DTypeLike","kind":"Gdef","module_hidden":true,"module_public":false},"_FName":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.lib._npyio_impl._FName","name":"_FName","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3}}},"_FNameRead":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.lib._npyio_impl._FNameRead","name":"_FNameRead","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3}}},"_FNameWrite":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.lib._npyio_impl._FNameWrite","name":"_FNameWrite","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3}}},"_FNameWriteBytes":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.lib._npyio_impl._FNameWriteBytes","name":"_FNameWriteBytes","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3}}},"_ScalarT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._npyio_impl._ScalarT","name":"_ScalarT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},"_ScalarT_co":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"fullname":"numpy.lib._npyio_impl._ScalarT_co","name":"_ScalarT_co","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}},"_SupportsArrayFunc":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._SupportsArrayFunc","kind":"Gdef","module_hidden":true,"module_public":false},"_SupportsReadSeek":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._npyio_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._npyio_impl._SupportsReadSeek","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"_typeshed.SupportsRead"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.lib._npyio_impl._SupportsReadSeek","name":"_SupportsReadSeek","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._npyio_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._npyio_impl._SupportsReadSeek","upper_bound":"builtins.object","values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy.lib._npyio_impl._SupportsReadSeek","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.lib._npyio_impl","mro":["numpy.lib._npyio_impl._SupportsReadSeek","_typeshed.SupportsRead","builtins.object"],"names":{".class":"SymbolTable","seek":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":[null,null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._npyio_impl._SupportsReadSeek.seek","name":"seek","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._npyio_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._npyio_impl._SupportsReadSeek","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._npyio_impl._SupportsReadSeek"},"builtins.int","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"seek of _SupportsReadSeek","ret_type":"builtins.object","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._npyio_impl._SupportsReadSeek.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._npyio_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._npyio_impl._SupportsReadSeek","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._npyio_impl._SupportsReadSeek"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_T_co"],"typeddict_type":null}},"_T_co":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._npyio_impl._T_co","name":"_T_co","upper_bound":"builtins.object","values":[],"variance":1}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib._npyio_impl.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._npyio_impl.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._npyio_impl.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._npyio_impl.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._npyio_impl.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._npyio_impl.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._npyio_impl.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"deprecated":{".class":"SymbolTableNode","cross_ref":"typing_extensions.deprecated","kind":"Gdef","module_hidden":true,"module_public":false},"fromregex":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._npyio_impl.fromregex","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["file","regexp","dtype","encoding"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._npyio_impl.fromregex","name":"fromregex","original_first_arg":"file","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["file","regexp","dtype","encoding"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str","builtins.bytes",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"re.Pattern"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromregex","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._npyio_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._npyio_impl.fromregex#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._npyio_impl.fromregex","name":"fromregex","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["file","regexp","dtype","encoding"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str","builtins.bytes",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"re.Pattern"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromregex","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._npyio_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._npyio_impl.fromregex#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["file","regexp","dtype","encoding"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._npyio_impl.fromregex","name":"fromregex","original_first_arg":"file","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["file","regexp","dtype","encoding"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str","builtins.bytes",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"re.Pattern"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromregex","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._npyio_impl.fromregex","name":"fromregex","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["file","regexp","dtype","encoding"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str","builtins.bytes",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"re.Pattern"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromregex","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["file","regexp","dtype","encoding"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str","builtins.bytes",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"re.Pattern"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromregex","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._npyio_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._npyio_impl.fromregex#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["file","regexp","dtype","encoding"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str","builtins.bytes",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"re.Pattern"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromregex","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"genfromtxt":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._npyio_impl.genfromtxt","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5],"arg_names":["fname","dtype","comments","delimiter","skip_header","skip_footer","converters","missing_values","filling_values","usecols","names","excludelist","deletechars","replace_space","autostrip","case_sensitive","defaultfmt","unpack","usemask","loose","invalid_raise","max_rows","encoding","ndmin","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._npyio_impl.genfromtxt","name":"genfromtxt","original_first_arg":"fname","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5],"arg_names":["fname","dtype","comments","delimiter","skip_header","skip_footer","converters","missing_values","filling_values","usecols","names","excludelist","deletechars","replace_space","autostrip","case_sensitive","defaultfmt","unpack","usemask","loose","invalid_raise","max_rows","encoding","ndmin","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.str",{".class":"UnionType","items":["builtins.str","builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int","builtins.int",{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":true},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":true},"builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Collection"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str","builtins.str","builtins.bool",{".class":"UnionType","items":["builtins.bool",{".class":"LiteralType","fallback":"builtins.str","value":"upper"},{".class":"LiteralType","fallback":"builtins.str","value":"lower"}],"uses_pep604_syntax":true},"builtins.str",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool","builtins.bool",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.int","value":0},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"LiteralType","fallback":"builtins.int","value":2}],"uses_pep604_syntax":false},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"genfromtxt","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._npyio_impl.genfromtxt","name":"genfromtxt","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5],"arg_names":["fname","dtype","comments","delimiter","skip_header","skip_footer","converters","missing_values","filling_values","usecols","names","excludelist","deletechars","replace_space","autostrip","case_sensitive","defaultfmt","unpack","usemask","loose","invalid_raise","max_rows","encoding","ndmin","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.str",{".class":"UnionType","items":["builtins.str","builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int","builtins.int",{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":true},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":true},"builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Collection"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str","builtins.str","builtins.bool",{".class":"UnionType","items":["builtins.bool",{".class":"LiteralType","fallback":"builtins.str","value":"upper"},{".class":"LiteralType","fallback":"builtins.str","value":"lower"}],"uses_pep604_syntax":true},"builtins.str",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool","builtins.bool",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.int","value":0},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"LiteralType","fallback":"builtins.int","value":2}],"uses_pep604_syntax":false},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"genfromtxt","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5],"arg_names":["fname","dtype","comments","delimiter","skip_header","skip_footer","converters","missing_values","filling_values","usecols","names","excludelist","deletechars","replace_space","autostrip","case_sensitive","defaultfmt","unpack","usemask","loose","invalid_raise","max_rows","encoding","ndmin","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._npyio_impl.genfromtxt","name":"genfromtxt","original_first_arg":"fname","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5],"arg_names":["fname","dtype","comments","delimiter","skip_header","skip_footer","converters","missing_values","filling_values","usecols","names","excludelist","deletechars","replace_space","autostrip","case_sensitive","defaultfmt","unpack","usemask","loose","invalid_raise","max_rows","encoding","ndmin","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.str",{".class":"UnionType","items":["builtins.str","builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int","builtins.int",{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":true},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":true},"builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Collection"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str","builtins.str","builtins.bool",{".class":"UnionType","items":["builtins.bool",{".class":"LiteralType","fallback":"builtins.str","value":"upper"},{".class":"LiteralType","fallback":"builtins.str","value":"lower"}],"uses_pep604_syntax":true},"builtins.str",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool","builtins.bool",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.int","value":0},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"LiteralType","fallback":"builtins.int","value":2}],"uses_pep604_syntax":false},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"genfromtxt","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._npyio_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._npyio_impl.genfromtxt#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._npyio_impl.genfromtxt","name":"genfromtxt","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5],"arg_names":["fname","dtype","comments","delimiter","skip_header","skip_footer","converters","missing_values","filling_values","usecols","names","excludelist","deletechars","replace_space","autostrip","case_sensitive","defaultfmt","unpack","usemask","loose","invalid_raise","max_rows","encoding","ndmin","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.str",{".class":"UnionType","items":["builtins.str","builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int","builtins.int",{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":true},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":true},"builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Collection"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str","builtins.str","builtins.bool",{".class":"UnionType","items":["builtins.bool",{".class":"LiteralType","fallback":"builtins.str","value":"upper"},{".class":"LiteralType","fallback":"builtins.str","value":"lower"}],"uses_pep604_syntax":true},"builtins.str",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool","builtins.bool",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.int","value":0},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"LiteralType","fallback":"builtins.int","value":2}],"uses_pep604_syntax":false},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"genfromtxt","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._npyio_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._npyio_impl.genfromtxt#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5],"arg_names":["fname","dtype","comments","delimiter","skip_header","skip_footer","converters","missing_values","filling_values","usecols","names","excludelist","deletechars","replace_space","autostrip","case_sensitive","defaultfmt","unpack","usemask","loose","invalid_raise","max_rows","encoding","ndmin","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._npyio_impl.genfromtxt","name":"genfromtxt","original_first_arg":"fname","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5],"arg_names":["fname","dtype","comments","delimiter","skip_header","skip_footer","converters","missing_values","filling_values","usecols","names","excludelist","deletechars","replace_space","autostrip","case_sensitive","defaultfmt","unpack","usemask","loose","invalid_raise","max_rows","encoding","ndmin","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.str",{".class":"UnionType","items":["builtins.str","builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int","builtins.int",{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":true},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":true},"builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Collection"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str","builtins.str","builtins.bool",{".class":"UnionType","items":["builtins.bool",{".class":"LiteralType","fallback":"builtins.str","value":"upper"},{".class":"LiteralType","fallback":"builtins.str","value":"lower"}],"uses_pep604_syntax":true},"builtins.str",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool","builtins.bool",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.int","value":0},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"LiteralType","fallback":"builtins.int","value":2}],"uses_pep604_syntax":false},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"genfromtxt","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._npyio_impl.genfromtxt","name":"genfromtxt","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5],"arg_names":["fname","dtype","comments","delimiter","skip_header","skip_footer","converters","missing_values","filling_values","usecols","names","excludelist","deletechars","replace_space","autostrip","case_sensitive","defaultfmt","unpack","usemask","loose","invalid_raise","max_rows","encoding","ndmin","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.str",{".class":"UnionType","items":["builtins.str","builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int","builtins.int",{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":true},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":true},"builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Collection"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str","builtins.str","builtins.bool",{".class":"UnionType","items":["builtins.bool",{".class":"LiteralType","fallback":"builtins.str","value":"upper"},{".class":"LiteralType","fallback":"builtins.str","value":"lower"}],"uses_pep604_syntax":true},"builtins.str",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool","builtins.bool",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.int","value":0},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"LiteralType","fallback":"builtins.int","value":2}],"uses_pep604_syntax":false},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"genfromtxt","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5],"arg_names":["fname","dtype","comments","delimiter","skip_header","skip_footer","converters","missing_values","filling_values","usecols","names","excludelist","deletechars","replace_space","autostrip","case_sensitive","defaultfmt","unpack","usemask","loose","invalid_raise","max_rows","encoding","ndmin","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.str",{".class":"UnionType","items":["builtins.str","builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int","builtins.int",{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":true},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":true},"builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Collection"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str","builtins.str","builtins.bool",{".class":"UnionType","items":["builtins.bool",{".class":"LiteralType","fallback":"builtins.str","value":"upper"},{".class":"LiteralType","fallback":"builtins.str","value":"lower"}],"uses_pep604_syntax":true},"builtins.str",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool","builtins.bool",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.int","value":0},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"LiteralType","fallback":"builtins.int","value":2}],"uses_pep604_syntax":false},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"genfromtxt","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5],"arg_names":["fname","dtype","comments","delimiter","skip_header","skip_footer","converters","missing_values","filling_values","usecols","names","excludelist","deletechars","replace_space","autostrip","case_sensitive","defaultfmt","unpack","usemask","loose","invalid_raise","max_rows","encoding","ndmin","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.str",{".class":"UnionType","items":["builtins.str","builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int","builtins.int",{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":true},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":true},"builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Collection"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str","builtins.str","builtins.bool",{".class":"UnionType","items":["builtins.bool",{".class":"LiteralType","fallback":"builtins.str","value":"upper"},{".class":"LiteralType","fallback":"builtins.str","value":"lower"}],"uses_pep604_syntax":true},"builtins.str",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool","builtins.bool",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.int","value":0},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"LiteralType","fallback":"builtins.int","value":2}],"uses_pep604_syntax":false},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"genfromtxt","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._npyio_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._npyio_impl.genfromtxt#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5],"arg_names":["fname","dtype","comments","delimiter","skip_header","skip_footer","converters","missing_values","filling_values","usecols","names","excludelist","deletechars","replace_space","autostrip","case_sensitive","defaultfmt","unpack","usemask","loose","invalid_raise","max_rows","encoding","ndmin","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.str",{".class":"UnionType","items":["builtins.str","builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int","builtins.int",{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":true},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":true},"builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Collection"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str","builtins.str","builtins.bool",{".class":"UnionType","items":["builtins.bool",{".class":"LiteralType","fallback":"builtins.str","value":"upper"},{".class":"LiteralType","fallback":"builtins.str","value":"lower"}],"uses_pep604_syntax":true},"builtins.str",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool","builtins.bool",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.int","value":0},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"LiteralType","fallback":"builtins.int","value":2}],"uses_pep604_syntax":false},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"genfromtxt","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"load":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,5],"arg_names":["file","mmap_mode","allow_pickle","fix_imports","encoding","max_header_size"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._npyio_impl.load","name":"load","original_first_arg":"file","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5],"arg_names":["file","mmap_mode","allow_pickle","fix_imports","encoding","max_header_size"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.StrOrBytesPath"},{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"numpy.lib._npyio_impl._SupportsReadSeek"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"r+"},{".class":"LiteralType","fallback":"builtins.str","value":"r"},{".class":"LiteralType","fallback":"builtins.str","value":"w+"},{".class":"LiteralType","fallback":"builtins.str","value":"c"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"ASCII"},{".class":"LiteralType","fallback":"builtins.str","value":"latin1"},{".class":"LiteralType","fallback":"builtins.str","value":"bytes"}],"uses_pep604_syntax":false},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"load","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"loadtxt":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._npyio_impl.loadtxt","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1,1,1,1,1,5,5],"arg_names":["fname","dtype","comments","delimiter","converters","skiprows","usecols","unpack","ndmin","encoding","max_rows","quotechar","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._npyio_impl.loadtxt","name":"loadtxt","original_first_arg":"fname","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,1,1,1,1,5,5],"arg_names":["fname","dtype","comments","delimiter","converters","skiprows","usecols","unpack","ndmin","encoding","max_rows","quotechar","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":true},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.int","value":0},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"LiteralType","fallback":"builtins.int","value":2}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"loadtxt","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._npyio_impl.loadtxt","name":"loadtxt","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,1,1,1,1,5,5],"arg_names":["fname","dtype","comments","delimiter","converters","skiprows","usecols","unpack","ndmin","encoding","max_rows","quotechar","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":true},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.int","value":0},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"LiteralType","fallback":"builtins.int","value":2}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"loadtxt","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,1,1,1,1,5,5],"arg_names":["fname","dtype","comments","delimiter","converters","skiprows","usecols","unpack","ndmin","encoding","max_rows","quotechar","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._npyio_impl.loadtxt","name":"loadtxt","original_first_arg":"fname","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1,1,1,1,5,5],"arg_names":["fname","dtype","comments","delimiter","converters","skiprows","usecols","unpack","ndmin","encoding","max_rows","quotechar","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":true},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.int","value":0},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"LiteralType","fallback":"builtins.int","value":2}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"loadtxt","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._npyio_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._npyio_impl.loadtxt#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._npyio_impl.loadtxt","name":"loadtxt","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1,1,1,1,5,5],"arg_names":["fname","dtype","comments","delimiter","converters","skiprows","usecols","unpack","ndmin","encoding","max_rows","quotechar","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":true},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.int","value":0},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"LiteralType","fallback":"builtins.int","value":2}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"loadtxt","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._npyio_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._npyio_impl.loadtxt#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,1,1,1,1,5,5],"arg_names":["fname","dtype","comments","delimiter","converters","skiprows","usecols","unpack","ndmin","encoding","max_rows","quotechar","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._npyio_impl.loadtxt","name":"loadtxt","original_first_arg":"fname","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1,1,1,1,5,5],"arg_names":["fname","dtype","comments","delimiter","converters","skiprows","usecols","unpack","ndmin","encoding","max_rows","quotechar","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":true},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.int","value":0},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"LiteralType","fallback":"builtins.int","value":2}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"loadtxt","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._npyio_impl.loadtxt","name":"loadtxt","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1,1,1,1,5,5],"arg_names":["fname","dtype","comments","delimiter","converters","skiprows","usecols","unpack","ndmin","encoding","max_rows","quotechar","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":true},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.int","value":0},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"LiteralType","fallback":"builtins.int","value":2}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"loadtxt","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,1,1,1,1,5,5],"arg_names":["fname","dtype","comments","delimiter","converters","skiprows","usecols","unpack","ndmin","encoding","max_rows","quotechar","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":true},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.int","value":0},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"LiteralType","fallback":"builtins.int","value":2}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"loadtxt","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1,1,1,1,5,5],"arg_names":["fname","dtype","comments","delimiter","converters","skiprows","usecols","unpack","ndmin","encoding","max_rows","quotechar","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":true},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.int","value":0},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"LiteralType","fallback":"builtins.int","value":2}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"loadtxt","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._npyio_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._npyio_impl.loadtxt#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1,1,1,1,5,5],"arg_names":["fname","dtype","comments","delimiter","converters","skiprows","usecols","unpack","ndmin","encoding","max_rows","quotechar","like"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":true},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.int","value":0},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"LiteralType","fallback":"builtins.int","value":2}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"loadtxt","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false},"override":{".class":"SymbolTableNode","cross_ref":"typing_extensions.override","kind":"Gdef","module_hidden":true,"module_public":false},"packbits":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.packbits","kind":"Gdef"},"recfromcsv":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._npyio_impl.recfromcsv","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,4],"arg_names":["fname","usemask","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._npyio_impl.recfromcsv","name":"recfromcsv","original_first_arg":"fname","type":{".class":"CallableType","arg_kinds":[0,5,4],"arg_names":["fname","usemask","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"recfromcsv","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":["numpy._core.records.record"],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._core.records.recarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._npyio_impl.recfromcsv","name":"recfromcsv","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,4],"arg_names":["fname","usemask","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"recfromcsv","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":["numpy._core.records.record"],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._core.records.recarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,4],"arg_names":["fname","usemask","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._npyio_impl.recfromcsv","name":"recfromcsv","original_first_arg":"fname","type":{".class":"CallableType","arg_kinds":[0,3,4],"arg_names":["fname","usemask","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"recfromcsv","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":["numpy.void"],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ma.mrecords.MaskedRecords"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._npyio_impl.recfromcsv","name":"recfromcsv","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,3,4],"arg_names":["fname","usemask","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"recfromcsv","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":["numpy.void"],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ma.mrecords.MaskedRecords"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,5,4],"arg_names":["fname","usemask","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"recfromcsv","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":["numpy._core.records.record"],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._core.records.recarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,3,4],"arg_names":["fname","usemask","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"recfromcsv","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":["numpy.void"],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ma.mrecords.MaskedRecords"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"recfromtxt":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._npyio_impl.recfromtxt","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,4],"arg_names":["fname","usemask","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._npyio_impl.recfromtxt","name":"recfromtxt","original_first_arg":"fname","type":{".class":"CallableType","arg_kinds":[0,5,4],"arg_names":["fname","usemask","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"recfromtxt","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":["numpy._core.records.record"],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._core.records.recarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._npyio_impl.recfromtxt","name":"recfromtxt","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,4],"arg_names":["fname","usemask","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"recfromtxt","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":["numpy._core.records.record"],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._core.records.recarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,4],"arg_names":["fname","usemask","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._npyio_impl.recfromtxt","name":"recfromtxt","original_first_arg":"fname","type":{".class":"CallableType","arg_kinds":[0,3,4],"arg_names":["fname","usemask","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"recfromtxt","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":["numpy.void"],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ma.mrecords.MaskedRecords"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._npyio_impl.recfromtxt","name":"recfromtxt","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,3,4],"arg_names":["fname","usemask","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"recfromtxt","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":["numpy.void"],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ma.mrecords.MaskedRecords"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,5,4],"arg_names":["fname","usemask","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"recfromtxt","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":["numpy._core.records.record"],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._core.records.recarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,3,4],"arg_names":["fname","usemask","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"recfromtxt","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":["numpy.void"],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ma.mrecords.MaskedRecords"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"save":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._npyio_impl.save","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["file","arr","allow_pickle"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._npyio_impl.save","name":"save","original_first_arg":"file","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["file","arr","allow_pickle"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"save","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._npyio_impl.save","name":"save","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["file","arr","allow_pickle"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"save","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["file","arr","allow_pickle","fix_imports"],"dataclass_transform_spec":null,"deprecated":"overload def (file: Any, arr: Any, allow_pickle: builtins.bool, fix_imports: builtins.bool) of function numpy.lib._npyio_impl.save is deprecated: The 'fix_imports' flag is deprecated in NumPy 2.1.","flags":["is_overload","is_decorated"],"fullname":"numpy.lib._npyio_impl.save","name":"save","original_first_arg":"file","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["file","arr","allow_pickle","fix_imports"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"save","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._npyio_impl.save","name":"save","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["file","arr","allow_pickle","fix_imports"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"save","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,3],"arg_names":["file","arr","allow_pickle","fix_imports"],"dataclass_transform_spec":null,"deprecated":"overload def (file: Any, arr: Any, allow_pickle: builtins.bool =, *, fix_imports: builtins.bool) of function numpy.lib._npyio_impl.save is deprecated: The 'fix_imports' flag is deprecated in NumPy 2.1.","flags":["is_overload","is_decorated"],"fullname":"numpy.lib._npyio_impl.save","name":"save","original_first_arg":"file","type":{".class":"CallableType","arg_kinds":[0,0,1,3],"arg_names":["file","arr","allow_pickle","fix_imports"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"save","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._npyio_impl.save","name":"save","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,3],"arg_names":["file","arr","allow_pickle","fix_imports"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"save","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["file","arr","allow_pickle"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"save","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["file","arr","allow_pickle","fix_imports"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"save","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,3],"arg_names":["file","arr","allow_pickle","fix_imports"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"save","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"savetxt":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,1,1],"arg_names":["fname","X","fmt","delimiter","newline","header","footer","comments","encoding"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._npyio_impl.savetxt","name":"savetxt","original_first_arg":"fname","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,1,1],"arg_names":["fname","X","fmt","delimiter","newline","header","footer","comments","encoding"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},"builtins.str","builtins.str","builtins.str","builtins.str","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"savetxt","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"savez":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,5,4],"arg_names":["file","args","allow_pickle","kwds"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._npyio_impl.savez","name":"savez","original_first_arg":"file","type":{".class":"CallableType","arg_kinds":[0,2,5,4],"arg_names":["file","args","allow_pickle","kwds"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"savez","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"savez_compressed":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,5,4],"arg_names":["file","args","allow_pickle","kwds"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._npyio_impl.savez_compressed","name":"savez_compressed","original_first_arg":"file","type":{".class":"CallableType","arg_kinds":[0,2,5,4],"arg_names":["file","args","allow_pickle","kwds"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._npyio_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"savez_compressed","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"type_check_only":{".class":"SymbolTableNode","cross_ref":"typing.type_check_only","kind":"Gdef","module_hidden":true,"module_public":false},"types":{".class":"SymbolTableNode","cross_ref":"types","kind":"Gdef","module_hidden":true,"module_public":false},"unpackbits":{".class":"SymbolTableNode","cross_ref":"numpy._core.multiarray.unpackbits","kind":"Gdef"},"zipfile":{".class":"SymbolTableNode","cross_ref":"zipfile","kind":"Gdef","module_hidden":true,"module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_npyio_impl.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_npyio_impl.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_npyio_impl.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..f5d96b2999c5c9c64b4ebad1c72f8c07f1c06103 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_npyio_impl.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[28,30,32,3,29,1,2,4,5,18,25,27,1,1,1,1,1,1,1,1,1],"dep_prios":[5,5,5,5,5,10,10,5,5,5,5,10,5,30,30,30,30,30,30,30,30],"dependencies":["numpy._core.multiarray","numpy.ma.mrecords","numpy.lib._datasource","collections.abc","numpy._typing","types","zipfile","re","typing","_typeshed","typing_extensions","numpy","builtins","_frozen_importlib","abc","numpy._core","numpy._core.records","numpy._typing._array_like","numpy.ma","numpy.ma.core","os"],"hash":"f4acc8041c9b42364c214626d4780623c433f3a9","id":"numpy.lib._npyio_impl","ignore_all":true,"interface_hash":"b355473846208b6a3ec248335ce8a8d2ea3bd222","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_npyio_impl.pyi","plugin_data":null,"size":9388,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_polynomial_impl.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_polynomial_impl.data.json new file mode 100644 index 0000000000000000000000000000000000000000..1860d0a83c75af0b35d6465ae06071bf627c675d --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_polynomial_impl.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.lib._polynomial_impl","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"L":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"NoReturn":{".class":"SymbolTableNode","cross_ref":"typing.NoReturn","kind":"Gdef","module_hidden":true,"module_public":false},"SupportsIndex":{".class":"SymbolTableNode","cross_ref":"typing.SupportsIndex","kind":"Gdef","module_hidden":true,"module_public":false},"SupportsInt":{".class":"SymbolTableNode","cross_ref":"typing.SupportsInt","kind":"Gdef","module_hidden":true,"module_public":false},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._polynomial_impl.TypeAlias","source_any":null,"type_of_any":3}}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"_2Tup":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.lib._polynomial_impl._2Tup","name":"_2Tup","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._polynomial_impl.TypeAlias","source_any":null,"type_of_any":3}}},"_5Tup":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.lib._polynomial_impl._5Tup","name":"_5Tup","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._polynomial_impl.TypeAlias","source_any":null,"type_of_any":3}}},"_ArrayLikeBool_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeBool_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeComplex_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeComplex_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeFloat_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeFloat_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeInt_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeInt_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeObject_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeObject_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeUInt_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeUInt_co","kind":"Gdef","module_hidden":true,"module_public":false},"_T":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._polynomial_impl._T","name":"_T","upper_bound":"builtins.object","values":[],"variance":0}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib._polynomial_impl.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._polynomial_impl.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._polynomial_impl.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._polynomial_impl.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._polynomial_impl.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._polynomial_impl.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._polynomial_impl.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"complex128":{".class":"SymbolTableNode","cross_ref":"numpy.complex128","kind":"Gdef","module_hidden":true,"module_public":false},"complexfloating":{".class":"SymbolTableNode","cross_ref":"numpy.complexfloating","kind":"Gdef","module_hidden":true,"module_public":false},"float64":{".class":"SymbolTableNode","cross_ref":"numpy.float64","kind":"Gdef","module_hidden":true,"module_public":false},"floating":{".class":"SymbolTableNode","cross_ref":"numpy.floating","kind":"Gdef","module_hidden":true,"module_public":false},"int32":{".class":"SymbolTableNode","cross_ref":"numpy.int32","kind":"Gdef","module_hidden":true,"module_public":false},"int64":{".class":"SymbolTableNode","cross_ref":"numpy.int64","kind":"Gdef","module_hidden":true,"module_public":false},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"object_":{".class":"SymbolTableNode","cross_ref":"numpy.object_","kind":"Gdef","module_hidden":true,"module_public":false},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false},"poly":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["seq_of_zeros"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._polynomial_impl.poly","name":"poly","original_first_arg":"seq_of_zeros","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["seq_of_zeros"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"poly","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"poly1d":{".class":"SymbolTableNode","cross_ref":"numpy.poly1d","kind":"Gdef"},"polyadd":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._polynomial_impl.polyadd","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a1","a2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polyadd","name":"polyadd","original_first_arg":"a1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":["numpy.poly1d",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyadd","ret_type":"numpy.poly1d","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polyadd","name":"polyadd","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":["numpy.poly1d",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyadd","ret_type":"numpy.poly1d","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a1","a2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polyadd","name":"polyadd","original_first_arg":"a1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"numpy.poly1d"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyadd","ret_type":"numpy.poly1d","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polyadd","name":"polyadd","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"numpy.poly1d"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyadd","ret_type":"numpy.poly1d","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a1","a2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polyadd","name":"polyadd","original_first_arg":"a1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyadd","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polyadd","name":"polyadd","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyadd","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a1","a2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polyadd","name":"polyadd","original_first_arg":"a1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyadd","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polyadd","name":"polyadd","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyadd","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a1","a2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polyadd","name":"polyadd","original_first_arg":"a1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyadd","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polyadd","name":"polyadd","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyadd","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a1","a2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polyadd","name":"polyadd","original_first_arg":"a1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyadd","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polyadd","name":"polyadd","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyadd","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a1","a2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polyadd","name":"polyadd","original_first_arg":"a1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyadd","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polyadd","name":"polyadd","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyadd","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a1","a2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polyadd","name":"polyadd","original_first_arg":"a1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyadd","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polyadd","name":"polyadd","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyadd","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":["numpy.poly1d",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyadd","ret_type":"numpy.poly1d","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"numpy.poly1d"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyadd","ret_type":"numpy.poly1d","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyadd","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyadd","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyadd","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyadd","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyadd","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyadd","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"polyder":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._polynomial_impl.polyder","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["p","m"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polyder","name":"polyder","original_first_arg":"p","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["p","m"],"arg_types":["numpy.poly1d",{".class":"UnionType","items":["typing.SupportsInt","typing.SupportsIndex"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyder","ret_type":"numpy.poly1d","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polyder","name":"polyder","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["p","m"],"arg_types":["numpy.poly1d",{".class":"UnionType","items":["typing.SupportsInt","typing.SupportsIndex"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyder","ret_type":"numpy.poly1d","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["p","m"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polyder","name":"polyder","original_first_arg":"p","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["p","m"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsInt","typing.SupportsIndex"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyder","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polyder","name":"polyder","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["p","m"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsInt","typing.SupportsIndex"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyder","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["p","m"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polyder","name":"polyder","original_first_arg":"p","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["p","m"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsInt","typing.SupportsIndex"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyder","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polyder","name":"polyder","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["p","m"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsInt","typing.SupportsIndex"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyder","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["p","m"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polyder","name":"polyder","original_first_arg":"p","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["p","m"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsInt","typing.SupportsIndex"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyder","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polyder","name":"polyder","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["p","m"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsInt","typing.SupportsIndex"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyder","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["p","m"],"arg_types":["numpy.poly1d",{".class":"UnionType","items":["typing.SupportsInt","typing.SupportsIndex"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyder","ret_type":"numpy.poly1d","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["p","m"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsInt","typing.SupportsIndex"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyder","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["p","m"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsInt","typing.SupportsIndex"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyder","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["p","m"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsInt","typing.SupportsIndex"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyder","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"polydiv":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._polynomial_impl.polydiv","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["u","v"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polydiv","name":"polydiv","original_first_arg":"u","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["u","v"],"arg_types":["numpy.poly1d",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polydiv","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._polynomial_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polydiv","name":"polydiv","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["u","v"],"arg_types":["numpy.poly1d",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polydiv","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._polynomial_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["u","v"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polydiv","name":"polydiv","original_first_arg":"u","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["u","v"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"numpy.poly1d"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polydiv","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._polynomial_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polydiv","name":"polydiv","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["u","v"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"numpy.poly1d"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polydiv","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._polynomial_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["u","v"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polydiv","name":"polydiv","original_first_arg":"u","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["u","v"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polydiv","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._polynomial_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polydiv","name":"polydiv","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["u","v"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polydiv","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._polynomial_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["u","v"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polydiv","name":"polydiv","original_first_arg":"u","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["u","v"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polydiv","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._polynomial_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polydiv","name":"polydiv","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["u","v"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polydiv","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._polynomial_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["u","v"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polydiv","name":"polydiv","original_first_arg":"u","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["u","v"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polydiv","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._polynomial_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polydiv","name":"polydiv","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["u","v"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polydiv","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._polynomial_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["u","v"],"arg_types":["numpy.poly1d",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polydiv","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._polynomial_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["u","v"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"numpy.poly1d"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polydiv","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._polynomial_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["u","v"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polydiv","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._polynomial_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["u","v"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polydiv","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._polynomial_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["u","v"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polydiv","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._polynomial_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"polyfit":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._polynomial_impl.polyfit","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1,1],"arg_names":["x","y","deg","rcond","full","w","cov"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polyfit","name":"polyfit","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1],"arg_names":["x","y","deg","rcond","full","w","cov"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex","typing.SupportsInt"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyfit","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polyfit","name":"polyfit","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1],"arg_names":["x","y","deg","rcond","full","w","cov"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex","typing.SupportsInt"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyfit","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1,1],"arg_names":["x","y","deg","rcond","full","w","cov"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polyfit","name":"polyfit","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1],"arg_names":["x","y","deg","rcond","full","w","cov"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex","typing.SupportsInt"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyfit","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polyfit","name":"polyfit","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1],"arg_names":["x","y","deg","rcond","full","w","cov"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex","typing.SupportsInt"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyfit","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1,3],"arg_names":["x","y","deg","rcond","full","w","cov"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polyfit","name":"polyfit","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,3],"arg_names":["x","y","deg","rcond","full","w","cov"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex","typing.SupportsInt"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.str","value":"unscaled"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyfit","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._polynomial_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polyfit","name":"polyfit","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,3],"arg_names":["x","y","deg","rcond","full","w","cov"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex","typing.SupportsInt"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.str","value":"unscaled"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyfit","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._polynomial_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1,3],"arg_names":["x","y","deg","rcond","full","w","cov"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polyfit","name":"polyfit","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,3],"arg_names":["x","y","deg","rcond","full","w","cov"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex","typing.SupportsInt"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.str","value":"unscaled"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyfit","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._polynomial_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polyfit","name":"polyfit","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,3],"arg_names":["x","y","deg","rcond","full","w","cov"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex","typing.SupportsInt"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.str","value":"unscaled"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyfit","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._polynomial_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1,1],"arg_names":["x","y","deg","rcond","full","w","cov"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polyfit","name":"polyfit","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1],"arg_names":["x","y","deg","rcond","full","w","cov"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex","typing.SupportsInt"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"LiteralType","fallback":"builtins.str","value":"unscaled"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyfit","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._polynomial_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polyfit","name":"polyfit","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1],"arg_names":["x","y","deg","rcond","full","w","cov"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex","typing.SupportsInt"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"LiteralType","fallback":"builtins.str","value":"unscaled"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyfit","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._polynomial_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1,1],"arg_names":["x","y","deg","rcond","full","w","cov"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polyfit","name":"polyfit","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1],"arg_names":["x","y","deg","rcond","full","w","cov"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex","typing.SupportsInt"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"LiteralType","fallback":"builtins.str","value":"unscaled"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyfit","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._polynomial_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polyfit","name":"polyfit","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1],"arg_names":["x","y","deg","rcond","full","w","cov"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex","typing.SupportsInt"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"LiteralType","fallback":"builtins.str","value":"unscaled"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyfit","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._polynomial_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1],"arg_names":["x","y","deg","rcond","full","w","cov"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex","typing.SupportsInt"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyfit","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1],"arg_names":["x","y","deg","rcond","full","w","cov"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex","typing.SupportsInt"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyfit","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,3],"arg_names":["x","y","deg","rcond","full","w","cov"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex","typing.SupportsInt"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.str","value":"unscaled"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyfit","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._polynomial_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,3],"arg_names":["x","y","deg","rcond","full","w","cov"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex","typing.SupportsInt"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"LiteralType","fallback":"builtins.str","value":"unscaled"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyfit","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._polynomial_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1],"arg_names":["x","y","deg","rcond","full","w","cov"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex","typing.SupportsInt"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"LiteralType","fallback":"builtins.str","value":"unscaled"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyfit","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._polynomial_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1],"arg_names":["x","y","deg","rcond","full","w","cov"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex","typing.SupportsInt"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"LiteralType","fallback":"builtins.str","value":"unscaled"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyfit","ret_type":{".class":"AnyType","missing_import_name":"numpy.lib._polynomial_impl.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"polyint":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._polynomial_impl.polyint","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["p","m","k"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polyint","name":"polyint","original_first_arg":"p","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["p","m","k"],"arg_types":["numpy.poly1d",{".class":"UnionType","items":["typing.SupportsInt","typing.SupportsIndex"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyint","ret_type":"numpy.poly1d","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polyint","name":"polyint","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["p","m","k"],"arg_types":["numpy.poly1d",{".class":"UnionType","items":["typing.SupportsInt","typing.SupportsIndex"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyint","ret_type":"numpy.poly1d","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["p","m","k"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polyint","name":"polyint","original_first_arg":"p","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["p","m","k"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsInt","typing.SupportsIndex"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyint","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polyint","name":"polyint","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["p","m","k"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsInt","typing.SupportsIndex"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyint","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["p","m","k"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polyint","name":"polyint","original_first_arg":"p","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["p","m","k"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsInt","typing.SupportsIndex"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyint","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polyint","name":"polyint","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["p","m","k"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsInt","typing.SupportsIndex"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyint","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["p","m","k"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polyint","name":"polyint","original_first_arg":"p","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["p","m","k"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsInt","typing.SupportsIndex"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyint","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polyint","name":"polyint","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["p","m","k"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsInt","typing.SupportsIndex"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyint","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["p","m","k"],"arg_types":["numpy.poly1d",{".class":"UnionType","items":["typing.SupportsInt","typing.SupportsIndex"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyint","ret_type":"numpy.poly1d","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["p","m","k"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsInt","typing.SupportsIndex"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyint","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["p","m","k"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsInt","typing.SupportsIndex"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyint","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["p","m","k"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsInt","typing.SupportsIndex"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyint","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"polymul":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib._polynomial_impl.polymul","name":"polymul","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":["numpy.poly1d",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"numpy.poly1d","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"numpy.poly1d"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"numpy.poly1d","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"polysub":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._polynomial_impl.polysub","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a1","a2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polysub","name":"polysub","original_first_arg":"a1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":["numpy.poly1d",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polysub","ret_type":"numpy.poly1d","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polysub","name":"polysub","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":["numpy.poly1d",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polysub","ret_type":"numpy.poly1d","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a1","a2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polysub","name":"polysub","original_first_arg":"a1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"numpy.poly1d"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polysub","ret_type":"numpy.poly1d","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polysub","name":"polysub","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"numpy.poly1d"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polysub","ret_type":"numpy.poly1d","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a1","a2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polysub","name":"polysub","original_first_arg":"a1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polysub","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polysub","name":"polysub","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polysub","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a1","a2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polysub","name":"polysub","original_first_arg":"a1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polysub","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polysub","name":"polysub","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polysub","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a1","a2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polysub","name":"polysub","original_first_arg":"a1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polysub","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polysub","name":"polysub","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polysub","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a1","a2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polysub","name":"polysub","original_first_arg":"a1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polysub","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polysub","name":"polysub","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polysub","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a1","a2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polysub","name":"polysub","original_first_arg":"a1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polysub","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polysub","name":"polysub","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polysub","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a1","a2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polysub","name":"polysub","original_first_arg":"a1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polysub","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polysub","name":"polysub","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polysub","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":["numpy.poly1d",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polysub","ret_type":"numpy.poly1d","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"numpy.poly1d"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polysub","ret_type":"numpy.poly1d","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polysub","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polysub","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polysub","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polysub","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polysub","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a1","a2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polysub","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"polyval":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._polynomial_impl.polyval","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["p","x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polyval","name":"polyval","original_first_arg":"p","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["p","x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyval","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polyval","name":"polyval","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["p","x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyval","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["p","x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polyval","name":"polyval","original_first_arg":"p","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["p","x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyval","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polyval","name":"polyval","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["p","x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyval","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["p","x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polyval","name":"polyval","original_first_arg":"p","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["p","x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyval","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polyval","name":"polyval","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["p","x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyval","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["p","x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polyval","name":"polyval","original_first_arg":"p","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["p","x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyval","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polyval","name":"polyval","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["p","x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyval","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["p","x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polyval","name":"polyval","original_first_arg":"p","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["p","x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyval","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polyval","name":"polyval","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["p","x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyval","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["p","x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._polynomial_impl.polyval","name":"polyval","original_first_arg":"p","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["p","x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyval","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._polynomial_impl.polyval","name":"polyval","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["p","x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyval","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["p","x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyval","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["p","x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyval","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["p","x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyval","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["p","x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyval","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["p","x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyval","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["p","x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"polyval","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"roots":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["p"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._polynomial_impl.roots","name":"roots","original_first_arg":"p","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["p"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"roots","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"signedinteger":{".class":"SymbolTableNode","cross_ref":"numpy.signedinteger","kind":"Gdef","module_hidden":true,"module_public":false},"unsignedinteger":{".class":"SymbolTableNode","cross_ref":"numpy.unsignedinteger","kind":"Gdef","module_hidden":true,"module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_polynomial_impl.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_polynomial_impl.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_polynomial_impl.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..9688d9a3231e192e9e5f776f8c64c6c4c941c6a8 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_polynomial_impl.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[27,1,14,1,1,1],"dep_prios":[5,5,5,5,30,30],"dependencies":["numpy._typing","typing","numpy","builtins","_frozen_importlib","abc"],"hash":"fff4b110caccc0110083fbe610dd97690d73e28b","id":"numpy.lib._polynomial_impl","ignore_all":true,"interface_hash":"d4a2b878269458c4adcbba9213a36fc94b6b503f","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_polynomial_impl.pyi","plugin_data":null,"size":7009,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_scimath_impl.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_scimath_impl.data.json new file mode 100644 index 0000000000000000000000000000000000000000..1b424674ba61e56a7887a74087a167431ec5e363 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_scimath_impl.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.lib._scimath_impl","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeComplex_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeComplex_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeFloat_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeFloat_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ComplexLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._ComplexLike_co","kind":"Gdef","module_hidden":true,"module_public":false},"_FloatLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._FloatLike_co","kind":"Gdef","module_hidden":true,"module_public":false},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib._scimath_impl.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._scimath_impl.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._scimath_impl.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._scimath_impl.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._scimath_impl.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._scimath_impl.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._scimath_impl.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"arccos":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._scimath_impl.arccos","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._scimath_impl.arccos","name":"arccos","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arccos","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._scimath_impl.arccos","name":"arccos","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arccos","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._scimath_impl.arccos","name":"arccos","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arccos","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._scimath_impl.arccos","name":"arccos","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arccos","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._scimath_impl.arccos","name":"arccos","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arccos","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._scimath_impl.arccos","name":"arccos","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arccos","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._scimath_impl.arccos","name":"arccos","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arccos","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._scimath_impl.arccos","name":"arccos","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arccos","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arccos","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arccos","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arccos","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arccos","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"arcsin":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._scimath_impl.arcsin","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._scimath_impl.arcsin","name":"arcsin","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arcsin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._scimath_impl.arcsin","name":"arcsin","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arcsin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._scimath_impl.arcsin","name":"arcsin","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arcsin","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._scimath_impl.arcsin","name":"arcsin","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arcsin","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._scimath_impl.arcsin","name":"arcsin","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arcsin","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._scimath_impl.arcsin","name":"arcsin","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arcsin","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._scimath_impl.arcsin","name":"arcsin","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arcsin","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._scimath_impl.arcsin","name":"arcsin","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arcsin","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arcsin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arcsin","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arcsin","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arcsin","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"arctanh":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._scimath_impl.arctanh","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._scimath_impl.arctanh","name":"arctanh","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arctanh","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._scimath_impl.arctanh","name":"arctanh","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arctanh","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._scimath_impl.arctanh","name":"arctanh","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arctanh","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._scimath_impl.arctanh","name":"arctanh","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arctanh","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._scimath_impl.arctanh","name":"arctanh","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arctanh","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._scimath_impl.arctanh","name":"arctanh","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arctanh","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._scimath_impl.arctanh","name":"arctanh","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arctanh","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._scimath_impl.arctanh","name":"arctanh","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arctanh","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arctanh","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arctanh","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arctanh","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"arctanh","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"complexfloating":{".class":"SymbolTableNode","cross_ref":"numpy.complexfloating","kind":"Gdef","module_hidden":true,"module_public":false},"log":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._scimath_impl.log","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._scimath_impl.log","name":"log","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"log","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._scimath_impl.log","name":"log","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"log","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._scimath_impl.log","name":"log","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"log","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._scimath_impl.log","name":"log","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"log","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._scimath_impl.log","name":"log","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"log","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._scimath_impl.log","name":"log","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"log","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._scimath_impl.log","name":"log","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"log","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._scimath_impl.log","name":"log","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"log","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"log","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"log","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"log","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"log","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"log10":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._scimath_impl.log10","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._scimath_impl.log10","name":"log10","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"log10","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._scimath_impl.log10","name":"log10","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"log10","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._scimath_impl.log10","name":"log10","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"log10","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._scimath_impl.log10","name":"log10","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"log10","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._scimath_impl.log10","name":"log10","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"log10","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._scimath_impl.log10","name":"log10","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"log10","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._scimath_impl.log10","name":"log10","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"log10","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._scimath_impl.log10","name":"log10","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"log10","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"log10","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"log10","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"log10","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"log10","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"log2":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._scimath_impl.log2","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._scimath_impl.log2","name":"log2","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"log2","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._scimath_impl.log2","name":"log2","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"log2","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._scimath_impl.log2","name":"log2","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"log2","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._scimath_impl.log2","name":"log2","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"log2","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._scimath_impl.log2","name":"log2","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"log2","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._scimath_impl.log2","name":"log2","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"log2","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._scimath_impl.log2","name":"log2","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"log2","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._scimath_impl.log2","name":"log2","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"log2","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"log2","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"log2","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"log2","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"log2","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"logn":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._scimath_impl.logn","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["n","x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._scimath_impl.logn","name":"logn","original_first_arg":"n","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["n","x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logn","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._scimath_impl.logn","name":"logn","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["n","x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logn","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["n","x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._scimath_impl.logn","name":"logn","original_first_arg":"n","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["n","x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logn","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._scimath_impl.logn","name":"logn","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["n","x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logn","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["n","x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._scimath_impl.logn","name":"logn","original_first_arg":"n","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["n","x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logn","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._scimath_impl.logn","name":"logn","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["n","x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logn","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["n","x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._scimath_impl.logn","name":"logn","original_first_arg":"n","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["n","x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logn","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._scimath_impl.logn","name":"logn","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["n","x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logn","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["n","x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logn","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["n","x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logn","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["n","x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logn","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["n","x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logn","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false},"power":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._scimath_impl.power","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x","p"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._scimath_impl.power","name":"power","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x","p"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"power","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._scimath_impl.power","name":"power","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x","p"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"power","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x","p"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._scimath_impl.power","name":"power","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x","p"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"power","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._scimath_impl.power","name":"power","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x","p"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"power","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x","p"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._scimath_impl.power","name":"power","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x","p"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"power","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._scimath_impl.power","name":"power","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x","p"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"power","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x","p"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._scimath_impl.power","name":"power","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x","p"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"power","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._scimath_impl.power","name":"power","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x","p"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"power","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x","p"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"power","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x","p"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"power","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x","p"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"power","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x","p"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"power","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"sqrt":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._scimath_impl.sqrt","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._scimath_impl.sqrt","name":"sqrt","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sqrt","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._scimath_impl.sqrt","name":"sqrt","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sqrt","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._scimath_impl.sqrt","name":"sqrt","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sqrt","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._scimath_impl.sqrt","name":"sqrt","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sqrt","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._scimath_impl.sqrt","name":"sqrt","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sqrt","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._scimath_impl.sqrt","name":"sqrt","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sqrt","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._scimath_impl.sqrt","name":"sqrt","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sqrt","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._scimath_impl.sqrt","name":"sqrt","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sqrt","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sqrt","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sqrt","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sqrt","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sqrt","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_scimath_impl.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_scimath_impl.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_scimath_impl.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..7c6bda143f22e2d974765081cc02d972e6df50cf --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_scimath_impl.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[4,1,3,1,1,1],"dep_prios":[5,5,5,5,30,30],"dependencies":["numpy._typing","typing","numpy","builtins","_frozen_importlib","abc"],"hash":"85143049fdba34805e412508da88e3b911e5ac62","id":"numpy.lib._scimath_impl","ignore_all":true,"interface_hash":"622461cf40a515fa7d828266ad586ad377360bcc","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_scimath_impl.pyi","plugin_data":null,"size":2774,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_shape_base_impl.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_shape_base_impl.data.json new file mode 100644 index 0000000000000000000000000000000000000000..bdca1f104e060ba2c991c7e015774ac3f77e0b87 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_shape_base_impl.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.lib._shape_base_impl","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef","module_hidden":true,"module_public":false},"Concatenate":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.lib._shape_base_impl.Concatenate","name":"Concatenate","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._shape_base_impl.Concatenate","source_any":null,"type_of_any":3}}},"DTypeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like.DTypeLike","kind":"Gdef","module_hidden":true,"module_public":false},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"ParamSpec":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.lib._shape_base_impl.ParamSpec","name":"ParamSpec","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._shape_base_impl.ParamSpec","source_any":null,"type_of_any":3}}},"Protocol":{".class":"SymbolTableNode","cross_ref":"typing.Protocol","kind":"Gdef","module_hidden":true,"module_public":false},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef","module_hidden":true,"module_public":false},"SupportsIndex":{".class":"SymbolTableNode","cross_ref":"typing.SupportsIndex","kind":"Gdef","module_hidden":true,"module_public":false},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeBool_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeBool_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeComplex_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeComplex_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeFloat_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeFloat_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeInt_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeInt_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeObject_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeObject_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeUInt_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeUInt_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayWrap":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.lib._shape_base_impl._ArrayWrap","name":"_ArrayWrap","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy.lib._shape_base_impl._ArrayWrap","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.lib._shape_base_impl","mro":["numpy.lib._shape_base_impl._ArrayWrap","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":[null,null,null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._shape_base_impl._ArrayWrap.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":[null,null,null,null],"arg_types":["numpy.lib._shape_base_impl._ArrayWrap",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"TupleType","implicit":false,"items":["numpy.ufunc",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"},"builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _ArrayWrap","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._ArrayWrap.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.lib._shape_base_impl._ArrayWrap","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_CastingKind":{".class":"SymbolTableNode","cross_ref":"numpy._CastingKind","kind":"Gdef","module_hidden":true,"module_public":false},"_P":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib._shape_base_impl._P","name":"_P","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._shape_base_impl.ParamSpec","source_any":{".class":"AnyType","missing_import_name":"numpy.lib._shape_base_impl.ParamSpec","source_any":null,"type_of_any":3},"type_of_any":7}}},"_ScalarT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._ScalarT","name":"_ScalarT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},"_ShapeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._shape._ShapeLike","kind":"Gdef","module_hidden":true,"module_public":false},"_SupportsArrayWrap":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.lib._shape_base_impl._SupportsArrayWrap","name":"_SupportsArrayWrap","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy.lib._shape_base_impl._SupportsArrayWrap","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.lib._shape_base_impl","mro":["numpy.lib._shape_base_impl._SupportsArrayWrap","builtins.object"],"names":{".class":"SymbolTable","__array_wrap__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy.lib._shape_base_impl._SupportsArrayWrap.__array_wrap__","name":"__array_wrap__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.lib._shape_base_impl._SupportsArrayWrap"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__array_wrap__ of _SupportsArrayWrap","ret_type":"numpy.lib._shape_base_impl._ArrayWrap","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy.lib._shape_base_impl._SupportsArrayWrap.__array_wrap__","name":"__array_wrap__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.lib._shape_base_impl._SupportsArrayWrap"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__array_wrap__ of _SupportsArrayWrap","ret_type":"numpy.lib._shape_base_impl._ArrayWrap","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._SupportsArrayWrap.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.lib._shape_base_impl._SupportsArrayWrap","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib._shape_base_impl.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._shape_base_impl.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._shape_base_impl.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._shape_base_impl.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._shape_base_impl.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._shape_base_impl.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._shape_base_impl.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"apply_along_axis":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._shape_base_impl.apply_along_axis","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,2,4],"arg_names":["func1d","axis","arr","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._shape_base_impl.apply_along_axis","name":"apply_along_axis","original_first_arg":"func1d","type":{".class":"CallableType","arg_kinds":[0,0,0,2,4],"arg_names":["func1d","axis","arr","args","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"apply_along_axis","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._shape_base_impl.apply_along_axis#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._shape_base_impl.apply_along_axis","name":"apply_along_axis","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,2,4],"arg_names":["func1d","axis","arr","args","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"apply_along_axis","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._shape_base_impl.apply_along_axis#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,2,4],"arg_names":["func1d","axis","arr","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._shape_base_impl.apply_along_axis","name":"apply_along_axis","original_first_arg":"func1d","type":{".class":"CallableType","arg_kinds":[0,0,0,2,4],"arg_names":["func1d","axis","arr","args","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"apply_along_axis","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._shape_base_impl.apply_along_axis","name":"apply_along_axis","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,2,4],"arg_names":["func1d","axis","arr","args","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"apply_along_axis","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,2,4],"arg_names":["func1d","axis","arr","args","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"apply_along_axis","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._shape_base_impl.apply_along_axis#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,2,4],"arg_names":["func1d","axis","arr","args","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"apply_along_axis","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"apply_over_axes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["func","a","axes"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._shape_base_impl.apply_over_axes","name":"apply_over_axes","original_first_arg":"func","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["func","a","axes"],"arg_types":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"apply_over_axes","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._shape_base_impl.apply_over_axes","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},"array_split":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._shape_base_impl.array_split","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["ary","indices_or_sections","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._shape_base_impl.array_split","name":"array_split","original_first_arg":"ary","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["ary","indices_or_sections","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array_split","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._shape_base_impl.array_split#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._shape_base_impl.array_split","name":"array_split","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["ary","indices_or_sections","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array_split","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._shape_base_impl.array_split#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["ary","indices_or_sections","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._shape_base_impl.array_split","name":"array_split","original_first_arg":"ary","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["ary","indices_or_sections","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array_split","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._shape_base_impl.array_split","name":"array_split","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["ary","indices_or_sections","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array_split","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["ary","indices_or_sections","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array_split","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._shape_base_impl.array_split#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["ary","indices_or_sections","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"array_split","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"column_stack":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._shape_base_impl.column_stack","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["tup"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._shape_base_impl.column_stack","name":"column_stack","original_first_arg":"tup","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["tup"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"column_stack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._shape_base_impl.column_stack#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._shape_base_impl.column_stack","name":"column_stack","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["tup"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"column_stack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._shape_base_impl.column_stack#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["tup"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._shape_base_impl.column_stack","name":"column_stack","original_first_arg":"tup","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["tup"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"column_stack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._shape_base_impl.column_stack","name":"column_stack","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["tup"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"column_stack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["tup"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"column_stack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._shape_base_impl.column_stack#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0],"arg_names":["tup"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"column_stack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"complexfloating":{".class":"SymbolTableNode","cross_ref":"numpy.complexfloating","kind":"Gdef","module_hidden":true,"module_public":false},"deprecated":{".class":"SymbolTableNode","cross_ref":"typing_extensions.deprecated","kind":"Gdef","module_hidden":true,"module_public":false},"dsplit":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._shape_base_impl.dsplit","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["ary","indices_or_sections"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._shape_base_impl.dsplit","name":"dsplit","original_first_arg":"ary","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["ary","indices_or_sections"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dsplit","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._shape_base_impl.dsplit#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._shape_base_impl.dsplit","name":"dsplit","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["ary","indices_or_sections"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dsplit","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._shape_base_impl.dsplit#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["ary","indices_or_sections"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._shape_base_impl.dsplit","name":"dsplit","original_first_arg":"ary","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["ary","indices_or_sections"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dsplit","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._shape_base_impl.dsplit","name":"dsplit","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["ary","indices_or_sections"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dsplit","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["ary","indices_or_sections"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dsplit","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._shape_base_impl.dsplit#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["ary","indices_or_sections"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dsplit","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"dstack":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._shape_base_impl.dstack","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["tup"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._shape_base_impl.dstack","name":"dstack","original_first_arg":"tup","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["tup"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dstack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._shape_base_impl.dstack#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._shape_base_impl.dstack","name":"dstack","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["tup"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dstack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._shape_base_impl.dstack#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["tup"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._shape_base_impl.dstack","name":"dstack","original_first_arg":"tup","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["tup"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dstack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._shape_base_impl.dstack","name":"dstack","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["tup"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dstack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["tup"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dstack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._shape_base_impl.dstack#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0],"arg_names":["tup"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dstack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"expand_dims":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._shape_base_impl.expand_dims","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._shape_base_impl.expand_dims","name":"expand_dims","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"expand_dims","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._shape_base_impl.expand_dims#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._shape_base_impl.expand_dims","name":"expand_dims","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"expand_dims","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._shape_base_impl.expand_dims#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._shape_base_impl.expand_dims","name":"expand_dims","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"expand_dims","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._shape_base_impl.expand_dims","name":"expand_dims","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"expand_dims","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"expand_dims","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._shape_base_impl.expand_dims#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"expand_dims","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"floating":{".class":"SymbolTableNode","cross_ref":"numpy.floating","kind":"Gdef","module_hidden":true,"module_public":false},"generic":{".class":"SymbolTableNode","cross_ref":"numpy.generic","kind":"Gdef","module_hidden":true,"module_public":false},"get_array_wrap":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._shape_base_impl.get_array_wrap","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[2],"arg_names":["args"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._shape_base_impl.get_array_wrap","name":"get_array_wrap","original_first_arg":"args","type":{".class":"CallableType","arg_kinds":[2],"arg_names":["args"],"arg_types":["numpy.lib._shape_base_impl._SupportsArrayWrap"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_array_wrap","ret_type":"numpy.lib._shape_base_impl._ArrayWrap","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._shape_base_impl.get_array_wrap","name":"get_array_wrap","setter_type":null,"type":{".class":"CallableType","arg_kinds":[2],"arg_names":["args"],"arg_types":["numpy.lib._shape_base_impl._SupportsArrayWrap"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_array_wrap","ret_type":"numpy.lib._shape_base_impl._ArrayWrap","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[2],"arg_names":["args"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._shape_base_impl.get_array_wrap","name":"get_array_wrap","original_first_arg":"args","type":{".class":"CallableType","arg_kinds":[2],"arg_names":["args"],"arg_types":["builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_array_wrap","ret_type":{".class":"UnionType","items":["numpy.lib._shape_base_impl._ArrayWrap",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._shape_base_impl.get_array_wrap","name":"get_array_wrap","setter_type":null,"type":{".class":"CallableType","arg_kinds":[2],"arg_names":["args"],"arg_types":["builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_array_wrap","ret_type":{".class":"UnionType","items":["numpy.lib._shape_base_impl._ArrayWrap",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[2],"arg_names":["args"],"arg_types":["numpy.lib._shape_base_impl._SupportsArrayWrap"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_array_wrap","ret_type":"numpy.lib._shape_base_impl._ArrayWrap","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[2],"arg_names":["args"],"arg_types":["builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_array_wrap","ret_type":{".class":"UnionType","items":["numpy.lib._shape_base_impl._ArrayWrap",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"hsplit":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._shape_base_impl.hsplit","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["ary","indices_or_sections"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._shape_base_impl.hsplit","name":"hsplit","original_first_arg":"ary","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["ary","indices_or_sections"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hsplit","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._shape_base_impl.hsplit#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._shape_base_impl.hsplit","name":"hsplit","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["ary","indices_or_sections"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hsplit","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._shape_base_impl.hsplit#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["ary","indices_or_sections"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._shape_base_impl.hsplit","name":"hsplit","original_first_arg":"ary","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["ary","indices_or_sections"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hsplit","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._shape_base_impl.hsplit","name":"hsplit","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["ary","indices_or_sections"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hsplit","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["ary","indices_or_sections"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hsplit","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._shape_base_impl.hsplit#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["ary","indices_or_sections"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hsplit","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"integer":{".class":"SymbolTableNode","cross_ref":"numpy.integer","kind":"Gdef","module_hidden":true,"module_public":false},"kron":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._shape_base_impl.kron","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","b"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._shape_base_impl.kron","name":"kron","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","b"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"kron","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._shape_base_impl.kron","name":"kron","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","b"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"kron","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","b"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._shape_base_impl.kron","name":"kron","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","b"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"kron","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._shape_base_impl.kron","name":"kron","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","b"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"kron","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","b"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._shape_base_impl.kron","name":"kron","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","b"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"kron","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._shape_base_impl.kron","name":"kron","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","b"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"kron","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","b"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._shape_base_impl.kron","name":"kron","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","b"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"kron","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._shape_base_impl.kron","name":"kron","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","b"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"kron","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","b"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._shape_base_impl.kron","name":"kron","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","b"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"kron","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._shape_base_impl.kron","name":"kron","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","b"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"kron","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","b"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._shape_base_impl.kron","name":"kron","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","b"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"kron","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._shape_base_impl.kron","name":"kron","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","b"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"kron","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","b"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._shape_base_impl.kron","name":"kron","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","b"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"kron","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._shape_base_impl.kron","name":"kron","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","b"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"kron","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","b"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"kron","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","b"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"kron","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","b"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"kron","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","b"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"kron","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","b"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"kron","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","b"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"kron","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","b"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"kron","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"object_":{".class":"SymbolTableNode","cross_ref":"numpy.object_","kind":"Gdef","module_hidden":true,"module_public":false},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false},"put_along_axis":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["arr","indices","values","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._shape_base_impl.put_along_axis","name":"put_along_axis","original_first_arg":"arr","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["arr","indices","values","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"put_along_axis","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._shape_base_impl.put_along_axis","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},"row_stack":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5],"arg_names":["tup","dtype","casting"],"dataclass_transform_spec":null,"deprecated":"function numpy.lib._shape_base_impl.row_stack is deprecated: `row_stack` alias is deprecated. Use `np.vstack` directly.","flags":["is_decorated"],"fullname":"numpy.lib._shape_base_impl.row_stack","name":"row_stack","original_first_arg":"tup","type":{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":["tup","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"row_stack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._shape_base_impl.row_stack","name":"row_stack","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":["tup","dtype","casting"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"row_stack","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"signedinteger":{".class":"SymbolTableNode","cross_ref":"numpy.signedinteger","kind":"Gdef","module_hidden":true,"module_public":false},"split":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._shape_base_impl.split","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["ary","indices_or_sections","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._shape_base_impl.split","name":"split","original_first_arg":"ary","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["ary","indices_or_sections","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"split","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._shape_base_impl.split#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._shape_base_impl.split","name":"split","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["ary","indices_or_sections","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"split","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._shape_base_impl.split#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["ary","indices_or_sections","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._shape_base_impl.split","name":"split","original_first_arg":"ary","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["ary","indices_or_sections","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"split","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._shape_base_impl.split","name":"split","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["ary","indices_or_sections","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"split","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["ary","indices_or_sections","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"split","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._shape_base_impl.split#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["ary","indices_or_sections","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"split","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"take_along_axis":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["arr","indices","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._shape_base_impl.take_along_axis","name":"take_along_axis","original_first_arg":"arr","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["arr","indices","axis"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._shape_base_impl.take_along_axis","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take_along_axis","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._shape_base_impl.take_along_axis","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},"tile":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._shape_base_impl.tile","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["A","reps"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._shape_base_impl.tile","name":"tile","original_first_arg":"A","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["A","reps"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._shape_base_impl.tile#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._shape_base_impl.tile","name":"tile","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["A","reps"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._shape_base_impl.tile#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["A","reps"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._shape_base_impl.tile","name":"tile","original_first_arg":"A","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["A","reps"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._shape_base_impl.tile","name":"tile","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["A","reps"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["A","reps"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._shape_base_impl.tile#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["A","reps"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tile","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"type_check_only":{".class":"SymbolTableNode","cross_ref":"typing.type_check_only","kind":"Gdef","module_hidden":true,"module_public":false},"ufunc":{".class":"SymbolTableNode","cross_ref":"numpy.ufunc","kind":"Gdef","module_hidden":true,"module_public":false},"unsignedinteger":{".class":"SymbolTableNode","cross_ref":"numpy.unsignedinteger","kind":"Gdef","module_hidden":true,"module_public":false},"vsplit":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._shape_base_impl.vsplit","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["ary","indices_or_sections"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._shape_base_impl.vsplit","name":"vsplit","original_first_arg":"ary","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["ary","indices_or_sections"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vsplit","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._shape_base_impl.vsplit#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._shape_base_impl.vsplit","name":"vsplit","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["ary","indices_or_sections"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vsplit","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._shape_base_impl.vsplit#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["ary","indices_or_sections"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._shape_base_impl.vsplit","name":"vsplit","original_first_arg":"ary","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["ary","indices_or_sections"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vsplit","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._shape_base_impl.vsplit","name":"vsplit","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["ary","indices_or_sections"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vsplit","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["ary","indices_or_sections"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vsplit","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._shape_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._shape_base_impl.vsplit#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["ary","indices_or_sections"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vsplit","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_shape_base_impl.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_shape_base_impl.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_shape_base_impl.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..3e9749fb787fbf9cecdd4b651d2438d7dc939a54 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_shape_base_impl.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,27,2,13,15,1,1,1],"dep_prios":[5,5,5,5,5,5,30,30],"dependencies":["collections.abc","numpy._typing","typing","typing_extensions","numpy","builtins","_frozen_importlib","abc"],"hash":"b8ac3edd24d3845dec624d3d439a01bb9f7a3e22","id":"numpy.lib._shape_base_impl","ignore_all":true,"interface_hash":"81b7d71390daeeb67d9e50d31576c02912829cd6","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_shape_base_impl.pyi","plugin_data":null,"size":5412,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_stride_tricks_impl.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_stride_tricks_impl.data.json new file mode 100644 index 0000000000000000000000000000000000000000..5cb48ee6bd5dec187bb9a1750f1432558e17dbe0 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_stride_tricks_impl.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.lib._stride_tricks_impl","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"DummyArray":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.lib._stride_tricks_impl.DummyArray","name":"DummyArray","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.lib._stride_tricks_impl.DummyArray","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.lib._stride_tricks_impl","mro":["numpy.lib._stride_tricks_impl.DummyArray","builtins.object"],"names":{".class":"SymbolTable","__array_interface__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._stride_tricks_impl.DummyArray.__array_interface__","name":"__array_interface__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","interface","base"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._stride_tricks_impl.DummyArray.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","interface","base"],"arg_types":["numpy.lib._stride_tricks_impl.DummyArray",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of DummyArray","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"base":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._stride_tricks_impl.DummyArray.base","name":"base","setter_type":null,"type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._stride_tricks_impl.DummyArray.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.lib._stride_tricks_impl.DummyArray","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef","module_hidden":true,"module_public":false},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"SupportsIndex":{".class":"SymbolTableNode","cross_ref":"typing.SupportsIndex","kind":"Gdef","module_hidden":true,"module_public":false},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"_AnyShape":{".class":"SymbolTableNode","cross_ref":"numpy._typing._shape._AnyShape","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"_ScalarT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._stride_tricks_impl._ScalarT","name":"_ScalarT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},"_ShapeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._shape._ShapeLike","kind":"Gdef","module_hidden":true,"module_public":false},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib._stride_tricks_impl.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._stride_tricks_impl.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._stride_tricks_impl.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._stride_tricks_impl.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._stride_tricks_impl.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._stride_tricks_impl.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._stride_tricks_impl.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"as_strided":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._stride_tricks_impl.as_strided","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["x","shape","strides","subok","writeable"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._stride_tricks_impl.as_strided","name":"as_strided","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["x","shape","strides","subok","writeable"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_strided","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._stride_tricks_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._stride_tricks_impl.as_strided#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._stride_tricks_impl.as_strided","name":"as_strided","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["x","shape","strides","subok","writeable"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_strided","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._stride_tricks_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._stride_tricks_impl.as_strided#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["x","shape","strides","subok","writeable"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._stride_tricks_impl.as_strided","name":"as_strided","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["x","shape","strides","subok","writeable"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_strided","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._stride_tricks_impl.as_strided","name":"as_strided","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["x","shape","strides","subok","writeable"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_strided","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["x","shape","strides","subok","writeable"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_strided","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._stride_tricks_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._stride_tricks_impl.as_strided#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["x","shape","strides","subok","writeable"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_strided","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"broadcast_arrays":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[2,5],"arg_names":["args","subok"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._stride_tricks_impl.broadcast_arrays","name":"broadcast_arrays","original_first_arg":"args","type":{".class":"CallableType","arg_kinds":[2,5],"arg_names":["args","subok"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"broadcast_arrays","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"broadcast_shapes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[2],"arg_names":["args"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._stride_tricks_impl.broadcast_shapes","name":"broadcast_shapes","original_first_arg":"args","type":{".class":"CallableType","arg_kinds":[2],"arg_names":["args"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"broadcast_shapes","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"broadcast_to":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._stride_tricks_impl.broadcast_to","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["array","shape","subok"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._stride_tricks_impl.broadcast_to","name":"broadcast_to","original_first_arg":"array","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["array","shape","subok"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"broadcast_to","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._stride_tricks_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._stride_tricks_impl.broadcast_to#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._stride_tricks_impl.broadcast_to","name":"broadcast_to","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["array","shape","subok"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"broadcast_to","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._stride_tricks_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._stride_tricks_impl.broadcast_to#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["array","shape","subok"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._stride_tricks_impl.broadcast_to","name":"broadcast_to","original_first_arg":"array","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["array","shape","subok"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"broadcast_to","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._stride_tricks_impl.broadcast_to","name":"broadcast_to","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["array","shape","subok"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"broadcast_to","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["array","shape","subok"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"broadcast_to","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._stride_tricks_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._stride_tricks_impl.broadcast_to#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["array","shape","subok"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"broadcast_to","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"generic":{".class":"SymbolTableNode","cross_ref":"numpy.generic","kind":"Gdef","module_hidden":true,"module_public":false},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false},"sliding_window_view":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._stride_tricks_impl.sliding_window_view","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,5,5],"arg_names":["x","window_shape","axis","subok","writeable"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._stride_tricks_impl.sliding_window_view","name":"sliding_window_view","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,1,5,5],"arg_names":["x","window_shape","axis","subok","writeable"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sliding_window_view","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._stride_tricks_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._stride_tricks_impl.sliding_window_view#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._stride_tricks_impl.sliding_window_view","name":"sliding_window_view","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,5,5],"arg_names":["x","window_shape","axis","subok","writeable"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sliding_window_view","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._stride_tricks_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._stride_tricks_impl.sliding_window_view#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,5,5],"arg_names":["x","window_shape","axis","subok","writeable"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._stride_tricks_impl.sliding_window_view","name":"sliding_window_view","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,1,5,5],"arg_names":["x","window_shape","axis","subok","writeable"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sliding_window_view","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._stride_tricks_impl.sliding_window_view","name":"sliding_window_view","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,5,5],"arg_names":["x","window_shape","axis","subok","writeable"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sliding_window_view","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,5,5],"arg_names":["x","window_shape","axis","subok","writeable"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sliding_window_view","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._stride_tricks_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._stride_tricks_impl.sliding_window_view#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,5,5],"arg_names":["x","window_shape","axis","subok","writeable"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sliding_window_view","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_stride_tricks_impl.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_stride_tricks_impl.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_stride_tricks_impl.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..5c49f2543ceaba45b6419a5320cb9409c9bbb498 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_stride_tricks_impl.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,5,2,4,1,1,1],"dep_prios":[5,5,5,5,5,30,30],"dependencies":["collections.abc","numpy._typing","typing","numpy","builtins","_frozen_importlib","abc"],"hash":"5251a9477c86a93688f25c9e737795a4a321b792","id":"numpy.lib._stride_tricks_impl","ignore_all":true,"interface_hash":"f8119a28b9908ed0048ebb24153381f6e9c957e0","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_stride_tricks_impl.pyi","plugin_data":null,"size":1815,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_twodim_base_impl.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_twodim_base_impl.data.json new file mode 100644 index 0000000000000000000000000000000000000000..12870996fc6ba43c3026a8ca93f440f0eb41d5f3 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_twodim_base_impl.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.lib._twodim_base_impl","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef","module_hidden":true,"module_public":false},"DTypeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like.DTypeLike","kind":"Gdef","module_hidden":true,"module_public":false},"L":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef","module_hidden":true,"module_public":false},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3}}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLike1D":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.lib._twodim_base_impl._ArrayLike1D","name":"_ArrayLike1D","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3}}},"_ArrayLike1DFloat_co":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.lib._twodim_base_impl._ArrayLike1DFloat_co","name":"_ArrayLike1DFloat_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3}}},"_ArrayLike1DInt_co":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.lib._twodim_base_impl._ArrayLike1DInt_co","name":"_ArrayLike1DInt_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3}}},"_ArrayLike1DNumber_co":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.lib._twodim_base_impl._ArrayLike1DNumber_co","name":"_ArrayLike1DNumber_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3}}},"_ArrayLike2DFloat_co":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.lib._twodim_base_impl._ArrayLike2DFloat_co","name":"_ArrayLike2DFloat_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3}}},"_ArrayLikeComplex_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeComplex_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeFloat_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeFloat_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeInt_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeInt_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeObject_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeObject_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ComplexFloatingT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ComplexFloatingT","name":"_ComplexFloatingT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"values":[],"variance":0}},"_DTypeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._DTypeLike","kind":"Gdef","module_hidden":true,"module_public":false},"_Float_co":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.lib._twodim_base_impl._Float_co","name":"_Float_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3}}},"_InexactT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._InexactT","name":"_InexactT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.inexact"},"values":[],"variance":0}},"_Int_co":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.lib._twodim_base_impl._Int_co","name":"_Int_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3}}},"_MaskFunc":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.lib._twodim_base_impl._MaskFunc","name":"_MaskFunc","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3}}},"_NumberCoT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._NumberCoT","name":"_NumberCoT","upper_bound":{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}},"_Number_co":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.lib._twodim_base_impl._Number_co","name":"_Number_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3}}},"_OrderCF":{".class":"SymbolTableNode","cross_ref":"numpy._OrderCF","kind":"Gdef","module_hidden":true,"module_public":false},"_ScalarT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ScalarT","name":"_ScalarT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},"_SupportsArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._SupportsArray","kind":"Gdef","module_hidden":true,"module_public":false},"_SupportsArrayFunc":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._SupportsArrayFunc","kind":"Gdef","module_hidden":true,"module_public":false},"_T":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._T","name":"_T","upper_bound":"builtins.object","values":[],"variance":0}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib._twodim_base_impl.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._twodim_base_impl.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._twodim_base_impl.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._twodim_base_impl.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._twodim_base_impl.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._twodim_base_impl.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._twodim_base_impl.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"complex128":{".class":"SymbolTableNode","cross_ref":"numpy.complex128","kind":"Gdef","module_hidden":true,"module_public":false},"complexfloating":{".class":"SymbolTableNode","cross_ref":"numpy.complexfloating","kind":"Gdef","module_hidden":true,"module_public":false},"datetime64":{".class":"SymbolTableNode","cross_ref":"numpy.datetime64","kind":"Gdef","module_hidden":true,"module_public":false},"diag":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._twodim_base_impl.diag","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["v","k"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.diag","name":"diag","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["v","k"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"diag","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._twodim_base_impl.diag#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.diag","name":"diag","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["v","k"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"diag","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._twodim_base_impl.diag#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["v","k"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.diag","name":"diag","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["v","k"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"diag","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.diag","name":"diag","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["v","k"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"diag","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["v","k"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"diag","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._twodim_base_impl.diag#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["v","k"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"diag","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"diagflat":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._twodim_base_impl.diagflat","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["v","k"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.diagflat","name":"diagflat","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["v","k"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"diagflat","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._twodim_base_impl.diagflat#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.diagflat","name":"diagflat","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["v","k"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"diagflat","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._twodim_base_impl.diagflat#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["v","k"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.diagflat","name":"diagflat","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["v","k"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"diagflat","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.diagflat","name":"diagflat","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["v","k"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"diagflat","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["v","k"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"diagflat","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._twodim_base_impl.diagflat#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["v","k"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"diagflat","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"eye":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._twodim_base_impl.eye","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,5,5],"arg_names":["N","M","k","dtype","order","device","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.eye","name":"eye","original_first_arg":"N","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5,5],"arg_names":["N","M","k","dtype","order","device","like"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eye","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.eye","name":"eye","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5,5],"arg_names":["N","M","k","dtype","order","device","like"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eye","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1,5,5],"arg_names":["N","M","k","dtype","order","device","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.eye","name":"eye","original_first_arg":"N","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,5,5],"arg_names":["N","M","k","dtype","order","device","like"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eye","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._twodim_base_impl.eye#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.eye","name":"eye","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,5,5],"arg_names":["N","M","k","dtype","order","device","like"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eye","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._twodim_base_impl.eye#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,3,5,5,5],"arg_names":["N","M","k","dtype","order","device","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.eye","name":"eye","original_first_arg":"N","type":{".class":"CallableType","arg_kinds":[0,1,1,3,5,5,5],"arg_names":["N","M","k","dtype","order","device","like"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eye","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._twodim_base_impl.eye#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.eye","name":"eye","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,3,5,5,5],"arg_names":["N","M","k","dtype","order","device","like"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eye","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._twodim_base_impl.eye#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,5,5],"arg_names":["N","M","k","dtype","order","device","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.eye","name":"eye","original_first_arg":"N","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5,5],"arg_names":["N","M","k","dtype","order","device","like"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eye","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.eye","name":"eye","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,5,5],"arg_names":["N","M","k","dtype","order","device","like"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eye","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1,5,5],"arg_names":["N","M","k","dtype","order","device","like"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eye","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1,5,5],"arg_names":["N","M","k","dtype","order","device","like"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eye","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._twodim_base_impl.eye#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,3,5,5,5],"arg_names":["N","M","k","dtype","order","device","like"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eye","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._twodim_base_impl.eye#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,5,5],"arg_names":["N","M","k","dtype","order","device","like"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"cpu"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eye","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"fliplr":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._twodim_base_impl.fliplr","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["m"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.fliplr","name":"fliplr","original_first_arg":"m","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["m"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fliplr","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._twodim_base_impl.fliplr#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.fliplr","name":"fliplr","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["m"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fliplr","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._twodim_base_impl.fliplr#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["m"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.fliplr","name":"fliplr","original_first_arg":"m","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["m"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fliplr","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.fliplr","name":"fliplr","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["m"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fliplr","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["m"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fliplr","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._twodim_base_impl.fliplr#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0],"arg_names":["m"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fliplr","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"flipud":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._twodim_base_impl.flipud","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["m"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.flipud","name":"flipud","original_first_arg":"m","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["m"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"flipud","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._twodim_base_impl.flipud#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.flipud","name":"flipud","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["m"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"flipud","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._twodim_base_impl.flipud#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["m"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.flipud","name":"flipud","original_first_arg":"m","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["m"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"flipud","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.flipud","name":"flipud","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["m"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"flipud","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["m"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"flipud","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._twodim_base_impl.flipud#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0],"arg_names":["m"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"flipud","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"float64":{".class":"SymbolTableNode","cross_ref":"numpy.float64","kind":"Gdef","module_hidden":true,"module_public":false},"floating":{".class":"SymbolTableNode","cross_ref":"numpy.floating","kind":"Gdef","module_hidden":true,"module_public":false},"generic":{".class":"SymbolTableNode","cross_ref":"numpy.generic","kind":"Gdef","module_hidden":true,"module_public":false},"histogram2d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._twodim_base_impl.histogram2d","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.histogram2d","name":"histogram2d","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ComplexFloatingT","id":-1,"name":"_ComplexFloatingT","namespace":"numpy.lib._twodim_base_impl.histogram2d#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.histogram2d","name":"histogram2d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ComplexFloatingT","id":-1,"name":"_ComplexFloatingT","namespace":"numpy.lib._twodim_base_impl.histogram2d#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.histogram2d","name":"histogram2d","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ComplexFloatingT","id":-1,"name":"_ComplexFloatingT","namespace":"numpy.lib._twodim_base_impl.histogram2d#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.histogram2d","name":"histogram2d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ComplexFloatingT","id":-1,"name":"_ComplexFloatingT","namespace":"numpy.lib._twodim_base_impl.histogram2d#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.histogram2d","name":"histogram2d","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._InexactT","id":-1,"name":"_InexactT","namespace":"numpy.lib._twodim_base_impl.histogram2d#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.inexact"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.histogram2d","name":"histogram2d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._InexactT","id":-1,"name":"_InexactT","namespace":"numpy.lib._twodim_base_impl.histogram2d#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.inexact"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.histogram2d","name":"histogram2d","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._InexactT","id":-1,"name":"_InexactT","namespace":"numpy.lib._twodim_base_impl.histogram2d#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.inexact"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.histogram2d","name":"histogram2d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._InexactT","id":-1,"name":"_InexactT","namespace":"numpy.lib._twodim_base_impl.histogram2d#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.inexact"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.histogram2d","name":"histogram2d","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.histogram2d","name":"histogram2d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.histogram2d","name":"histogram2d","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"Instance","args":["builtins.complex"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":["builtins.complex"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.histogram2d","name":"histogram2d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"Instance","args":["builtins.complex"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":["builtins.complex"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.histogram2d","name":"histogram2d","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._NumberCoT","id":-1,"name":"_NumberCoT","namespace":"numpy.lib._twodim_base_impl.histogram2d#6","upper_bound":{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.histogram2d","name":"histogram2d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._NumberCoT","id":-1,"name":"_NumberCoT","namespace":"numpy.lib._twodim_base_impl.histogram2d#6","upper_bound":{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.histogram2d","name":"histogram2d","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._InexactT","id":-1,"name":"_InexactT","namespace":"numpy.lib._twodim_base_impl.histogram2d#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.inexact"},"values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._NumberCoT","id":-2,"name":"_NumberCoT","namespace":"numpy.lib._twodim_base_impl.histogram2d#7","upper_bound":{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.histogram2d","name":"histogram2d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._InexactT","id":-1,"name":"_InexactT","namespace":"numpy.lib._twodim_base_impl.histogram2d#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.inexact"},"values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._NumberCoT","id":-2,"name":"_NumberCoT","namespace":"numpy.lib._twodim_base_impl.histogram2d#7","upper_bound":{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.histogram2d","name":"histogram2d","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._NumberCoT","id":-1,"name":"_NumberCoT","namespace":"numpy.lib._twodim_base_impl.histogram2d#8","upper_bound":{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.histogram2d","name":"histogram2d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._NumberCoT","id":-1,"name":"_NumberCoT","namespace":"numpy.lib._twodim_base_impl.histogram2d#8","upper_bound":{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.histogram2d","name":"histogram2d","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"Instance","args":["builtins.complex"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":["builtins.complex"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._NumberCoT","id":-1,"name":"_NumberCoT","namespace":"numpy.lib._twodim_base_impl.histogram2d#9","upper_bound":{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.histogram2d","name":"histogram2d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"Instance","args":["builtins.complex"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":["builtins.complex"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._NumberCoT","id":-1,"name":"_NumberCoT","namespace":"numpy.lib._twodim_base_impl.histogram2d#9","upper_bound":{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.histogram2d","name":"histogram2d","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.histogram2d","name":"histogram2d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.histogram2d","name":"histogram2d","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.histogram2d","name":"histogram2d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.histogram2d","name":"histogram2d","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.histogram2d","name":"histogram2d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.histogram2d","name":"histogram2d","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"Instance","args":["builtins.complex"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.histogram2d","name":"histogram2d","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"Instance","args":["builtins.complex"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ComplexFloatingT","id":-1,"name":"_ComplexFloatingT","namespace":"numpy.lib._twodim_base_impl.histogram2d#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ComplexFloatingT","id":-1,"name":"_ComplexFloatingT","namespace":"numpy.lib._twodim_base_impl.histogram2d#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._InexactT","id":-1,"name":"_InexactT","namespace":"numpy.lib._twodim_base_impl.histogram2d#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.inexact"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._InexactT","id":-1,"name":"_InexactT","namespace":"numpy.lib._twodim_base_impl.histogram2d#3","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.inexact"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"Instance","args":["builtins.complex"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":["builtins.complex"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._NumberCoT","id":-1,"name":"_NumberCoT","namespace":"numpy.lib._twodim_base_impl.histogram2d#6","upper_bound":{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._InexactT","id":-1,"name":"_InexactT","namespace":"numpy.lib._twodim_base_impl.histogram2d#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.inexact"},"values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._NumberCoT","id":-2,"name":"_NumberCoT","namespace":"numpy.lib._twodim_base_impl.histogram2d#7","upper_bound":{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._NumberCoT","id":-1,"name":"_NumberCoT","namespace":"numpy.lib._twodim_base_impl.histogram2d#8","upper_bound":{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"Instance","args":["builtins.complex"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":["builtins.complex"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._NumberCoT","id":-1,"name":"_NumberCoT","namespace":"numpy.lib._twodim_base_impl.histogram2d#9","upper_bound":{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["x","y","bins","range","density","weights"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"Instance","args":["builtins.complex"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"histogram2d","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"int_":{".class":"SymbolTableNode","cross_ref":"numpy.int_","kind":"Gdef","module_hidden":true,"module_public":false},"intp":{".class":"SymbolTableNode","cross_ref":"numpy.intp","kind":"Gdef","module_hidden":true,"module_public":false},"mask_indices":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._twodim_base_impl.mask_indices","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["n","mask_func","k"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.mask_indices","name":"mask_indices","original_first_arg":"n","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["n","mask_func","k"],"arg_types":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mask_indices","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.mask_indices","name":"mask_indices","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["n","mask_func","k"],"arg_types":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mask_indices","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["n","mask_func","k"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.mask_indices","name":"mask_indices","original_first_arg":"n","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["n","mask_func","k"],"arg_types":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._twodim_base_impl.mask_indices","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mask_indices","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._twodim_base_impl.mask_indices","upper_bound":"builtins.object","values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.mask_indices","name":"mask_indices","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["n","mask_func","k"],"arg_types":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._twodim_base_impl.mask_indices","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mask_indices","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._twodim_base_impl.mask_indices","upper_bound":"builtins.object","values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["n","mask_func","k"],"arg_types":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mask_indices","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["n","mask_func","k"],"arg_types":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.lib._twodim_base_impl.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._twodim_base_impl.mask_indices","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mask_indices","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._twodim_base_impl.mask_indices","upper_bound":"builtins.object","values":[],"variance":0}]}]}}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"object_":{".class":"SymbolTableNode","cross_ref":"numpy.object_","kind":"Gdef","module_hidden":true,"module_public":false},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false},"signedinteger":{".class":"SymbolTableNode","cross_ref":"numpy.signedinteger","kind":"Gdef","module_hidden":true,"module_public":false},"timedelta64":{".class":"SymbolTableNode","cross_ref":"numpy.timedelta64","kind":"Gdef","module_hidden":true,"module_public":false},"tri":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._twodim_base_impl.tri","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,5],"arg_names":["N","M","k","dtype","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.tri","name":"tri","original_first_arg":"N","type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["N","M","k","dtype","like"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"NoneType"},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tri","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.tri","name":"tri","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["N","M","k","dtype","like"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"NoneType"},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tri","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,5],"arg_names":["N","M","k","dtype","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.tri","name":"tri","original_first_arg":"N","type":{".class":"CallableType","arg_kinds":[0,0,0,0,5],"arg_names":["N","M","k","dtype","like"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tri","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._twodim_base_impl.tri#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.tri","name":"tri","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,5],"arg_names":["N","M","k","dtype","like"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tri","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._twodim_base_impl.tri#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,3,5],"arg_names":["N","M","k","dtype","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.tri","name":"tri","original_first_arg":"N","type":{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["N","M","k","dtype","like"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tri","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._twodim_base_impl.tri#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.tri","name":"tri","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["N","M","k","dtype","like"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tri","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._twodim_base_impl.tri#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,5],"arg_names":["N","M","k","dtype","like"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.tri","name":"tri","original_first_arg":"N","type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["N","M","k","dtype","like"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tri","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.tri","name":"tri","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["N","M","k","dtype","like"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tri","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["N","M","k","dtype","like"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"NoneType"},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tri","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,5],"arg_names":["N","M","k","dtype","like"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tri","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._twodim_base_impl.tri#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["N","M","k","dtype","like"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tri","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._twodim_base_impl.tri#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["N","M","k","dtype","like"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["numpy._typing._array_like._SupportsArrayFunc",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tri","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"tril":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._twodim_base_impl.tril","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["m","k"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.tril","name":"tril","original_first_arg":"m","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["m","k"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tril","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._twodim_base_impl.tril#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.tril","name":"tril","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["m","k"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tril","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._twodim_base_impl.tril#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["m","k"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.tril","name":"tril","original_first_arg":"m","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["m","k"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tril","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.tril","name":"tril","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["m","k"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tril","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["m","k"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tril","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._twodim_base_impl.tril#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["m","k"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tril","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"tril_indices":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["n","k","m"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._twodim_base_impl.tril_indices","name":"tril_indices","original_first_arg":"n","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["n","k","m"],"arg_types":["builtins.int","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tril_indices","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"tril_indices_from":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["arr","k"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._twodim_base_impl.tril_indices_from","name":"tril_indices_from","original_first_arg":"arr","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["arr","k"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tril_indices_from","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"triu":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._twodim_base_impl.triu","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["m","k"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.triu","name":"triu","original_first_arg":"m","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["m","k"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"triu","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._twodim_base_impl.triu#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.triu","name":"triu","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["m","k"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"triu","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._twodim_base_impl.triu#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["m","k"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.triu","name":"triu","original_first_arg":"m","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["m","k"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"triu","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.triu","name":"triu","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["m","k"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"triu","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["m","k"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"triu","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._twodim_base_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._twodim_base_impl.triu#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["m","k"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"triu","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"triu_indices":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["n","k","m"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._twodim_base_impl.triu_indices","name":"triu_indices","original_first_arg":"n","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["n","k","m"],"arg_types":["builtins.int","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"triu_indices","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"triu_indices_from":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["arr","k"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._twodim_base_impl.triu_indices_from","name":"triu_indices_from","original_first_arg":"arr","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["arr","k"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"triu_indices_from","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"vander":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._twodim_base_impl.vander","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["x","N","increasing"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.vander","name":"vander","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["x","N","increasing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vander","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.vander","name":"vander","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["x","N","increasing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vander","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["x","N","increasing"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.vander","name":"vander","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["x","N","increasing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vander","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.vander","name":"vander","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["x","N","increasing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vander","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["x","N","increasing"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.vander","name":"vander","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["x","N","increasing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vander","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.vander","name":"vander","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["x","N","increasing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vander","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["x","N","increasing"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._twodim_base_impl.vander","name":"vander","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["x","N","increasing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vander","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._twodim_base_impl.vander","name":"vander","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["x","N","increasing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vander","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["x","N","increasing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vander","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["x","N","increasing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vander","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["x","N","increasing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vander","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["x","N","increasing"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vander","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_twodim_base_impl.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_twodim_base_impl.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_twodim_base_impl.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..d77463d739e829b38d12b5eca6ec7d6e145b2d09 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_twodim_base_impl.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,27,2,12,1,1,1,1,1,1,1],"dep_prios":[5,5,5,5,5,30,30,30,30,30,30],"dependencies":["collections.abc","numpy._typing","typing","numpy","builtins","_frozen_importlib","_typeshed","abc","datetime","numpy._typing._array_like","numpy._typing._nbit_base"],"hash":"5a487c8e511bc37d842bb565e50012c92947e0df","id":"numpy.lib._twodim_base_impl","ignore_all":true,"interface_hash":"dab211c49122e5435a43b99bf8b8e03f0a219078","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_twodim_base_impl.pyi","plugin_data":null,"size":11193,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_type_check_impl.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_type_check_impl.data.json new file mode 100644 index 0000000000000000000000000000000000000000..f5f96c8deefec708422722ac2c8f860000af04dd --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_type_check_impl.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.lib._type_check_impl","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"Container":{".class":"SymbolTableNode","cross_ref":"typing.Container","kind":"Gdef","module_hidden":true,"module_public":false},"Incomplete":{".class":"SymbolTableNode","cross_ref":"_typeshed.Incomplete","kind":"Gdef","module_hidden":true,"module_public":false},"Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef","module_hidden":true,"module_public":false},"L":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"Protocol":{".class":"SymbolTableNode","cross_ref":"typing.Protocol","kind":"Gdef","module_hidden":true,"module_public":false},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing_extensions.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"_16Bit":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nbit_base._16Bit","kind":"Gdef","module_hidden":true,"module_public":false},"_32Bit":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nbit_base._32Bit","kind":"Gdef","module_hidden":true,"module_public":false},"_64Bit":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nbit_base._64Bit","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"_ComplexMax128":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.lib._type_check_impl._ComplexMax128","name":"_ComplexMax128","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}}},"_FloatMax32":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.lib._type_check_impl._FloatMax32","name":"_FloatMax32","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}}},"_HasDType":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.lib._type_check_impl._HasDType","name":"_HasDType","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._type_check_impl._HasDType","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy.lib._type_check_impl._HasDType","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.lib._type_check_impl","mro":["numpy.lib._type_check_impl._HasDType","builtins.object"],"names":{".class":"SymbolTable","dtype":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy.lib._type_check_impl._HasDType.dtype","name":"dtype","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._type_check_impl._HasDType","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dtype of _HasDType","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._type_check_impl._HasDType","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.dtype"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl._HasDType.dtype","name":"dtype","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._type_check_impl._HasDType","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dtype of _HasDType","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._type_check_impl._HasDType","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.dtype"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._HasDType.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._ScalarT_co","id":1,"name":"_ScalarT_co","namespace":"numpy.lib._type_check_impl._HasDType","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_ScalarT_co"],"typeddict_type":null}},"_HasImag":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.lib._type_check_impl._HasImag","name":"_HasImag","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._type_check_impl._HasImag","upper_bound":"builtins.object","values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy.lib._type_check_impl._HasImag","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.lib._type_check_impl","mro":["numpy.lib._type_check_impl._HasImag","builtins.object"],"names":{".class":"SymbolTable","imag":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy.lib._type_check_impl._HasImag.imag","name":"imag","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._type_check_impl._HasImag","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasImag"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"imag of _HasImag","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._type_check_impl._HasImag","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl._HasImag.imag","name":"imag","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._type_check_impl._HasImag","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasImag"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"imag of _HasImag","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._type_check_impl._HasImag","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._HasImag.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._type_check_impl._HasImag","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasImag"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_T_co"],"typeddict_type":null}},"_HasReal":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.lib._type_check_impl._HasReal","name":"_HasReal","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._type_check_impl._HasReal","upper_bound":"builtins.object","values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy.lib._type_check_impl._HasReal","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.lib._type_check_impl","mro":["numpy.lib._type_check_impl._HasReal","builtins.object"],"names":{".class":"SymbolTable","real":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy.lib._type_check_impl._HasReal.real","name":"real","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._type_check_impl._HasReal","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasReal"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"real of _HasReal","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._type_check_impl._HasReal","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl._HasReal.real","name":"real","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._type_check_impl._HasReal","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasReal"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"real of _HasReal","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._type_check_impl._HasReal","upper_bound":"builtins.object","values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._HasReal.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._T_co","id":1,"name":"_T_co","namespace":"numpy.lib._type_check_impl._HasReal","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasReal"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_T_co"],"typeddict_type":null}},"_InexactMax32":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.lib._type_check_impl._InexactMax32","name":"_InexactMax32","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}}},"_NestedSequence":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nested_sequence._NestedSequence","kind":"Gdef","module_hidden":true,"module_public":false},"_NumberMax64":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.lib._type_check_impl._NumberMax64","name":"_NumberMax64","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}}},"_Real":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.lib._type_check_impl._Real","name":"_Real","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}}},"_RealMax64":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.lib._type_check_impl._RealMax64","name":"_RealMax64","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}}},"_RealT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._RealT","name":"_RealT","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"uses_pep604_syntax":true},"values":[],"variance":0}},"_ScalarLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._ScalarLike_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ScalarT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._ScalarT","name":"_ScalarT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},"_ScalarT_co":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._ScalarT_co","name":"_ScalarT_co","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}},"_SupportsArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._SupportsArray","kind":"Gdef","module_hidden":true,"module_public":false},"_T":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._T","name":"_T","upper_bound":"builtins.object","values":[],"variance":0}},"_T_co":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._T_co","name":"_T_co","upper_bound":"builtins.object","values":[],"variance":1}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib._type_check_impl.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._type_check_impl.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._type_check_impl.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._type_check_impl.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._type_check_impl.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._type_check_impl.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._type_check_impl.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"common_type":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._type_check_impl.common_type","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2],"arg_names":[null,"ai"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0,2],"arg_names":[null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,2],"arg_names":[null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2],"arg_names":[null,"ai"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0,2],"arg_names":[null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,2],"arg_names":[null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2],"arg_names":[null,"ai"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0,2],"arg_names":[null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"UnionType","items":["numpy.float64",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":"numpy.float64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,2],"arg_names":[null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"UnionType","items":["numpy.float64",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":"numpy.float64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2],"arg_names":[null,"ai"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0,2],"arg_names":[null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,2],"arg_names":[null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2],"arg_names":[null,"ai"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0,2],"arg_names":[null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,2],"arg_names":[null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2],"arg_names":[null,"ai"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0,2],"arg_names":[null,"ai"],"arg_types":[{".class":"Instance","args":["numpy.complex128"],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":"numpy.complex128"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,2],"arg_names":[null,"ai"],"arg_types":[{".class":"Instance","args":["numpy.complex128"],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":"numpy.complex128"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2],"arg_names":[null,"ai"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0,2],"arg_names":[null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,2],"arg_names":[null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"UnionType","items":["numpy.float64",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":"numpy.float64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"UnionType","items":["numpy.float64",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":"numpy.float64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":["numpy.float64"],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":"numpy.complex128"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":["numpy.float64"],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":"numpy.complex128"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":["numpy.float64"],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":"numpy.complex128"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":["numpy.float64"],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":"numpy.complex128"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":["numpy.complex128"],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":"numpy.complex128"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":["numpy.complex128"],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":"numpy.complex128"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"UnionType","items":["numpy.complex128",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":"numpy.complex128"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"UnionType","items":["numpy.complex128",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":"numpy.complex128"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"UnionType","items":["numpy.complex128",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":"numpy.complex128"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"UnionType","items":["numpy.complex128",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":"numpy.complex128"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2],"arg_names":[null,"ai"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0,2],"arg_names":[null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,2],"arg_names":[null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","original_first_arg":"a0","type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.common_type","name":"common_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,2],"arg_names":[null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,2],"arg_names":[null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,2],"arg_names":[null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"UnionType","items":["numpy.float64",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":"numpy.float64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,2],"arg_names":[null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,2],"arg_names":[null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,2],"arg_names":[null,"ai"],"arg_types":[{".class":"Instance","args":["numpy.complex128"],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":"numpy.complex128"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,2],"arg_names":[null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"UnionType","items":["numpy.float64",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":"numpy.float64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":["numpy.float64"],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":"numpy.complex128"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":["numpy.float64"],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":"numpy.complex128"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":["numpy.complex128"],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":"numpy.complex128"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"UnionType","items":["numpy.complex128",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":"numpy.complex128"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"UnionType","items":["numpy.complex128",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":"numpy.complex128"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,2],"arg_names":[null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.lib._type_check_impl.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,2],"arg_names":[null,null,"ai"],"arg_types":[{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"common_type","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"imag":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._type_check_impl.imag","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["val"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.imag","name":"imag","original_first_arg":"val","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["val"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._type_check_impl.imag#0","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasImag"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"imag","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._type_check_impl.imag#0","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._type_check_impl.imag#0","upper_bound":"builtins.object","values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.imag","name":"imag","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["val"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._type_check_impl.imag#0","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasImag"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"imag","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._type_check_impl.imag#0","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._type_check_impl.imag#0","upper_bound":"builtins.object","values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["val"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.imag","name":"imag","original_first_arg":"val","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["val"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"imag","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._RealT","id":-1,"name":"_RealT","namespace":"numpy.lib._type_check_impl.imag#1","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"uses_pep604_syntax":true},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.imag","name":"imag","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["val"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"imag","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._RealT","id":-1,"name":"_RealT","namespace":"numpy.lib._type_check_impl.imag#1","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"uses_pep604_syntax":true},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["val"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.imag","name":"imag","original_first_arg":"val","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["val"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"imag","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.imag","name":"imag","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["val"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"imag","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["val"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._type_check_impl.imag#0","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasImag"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"imag","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._type_check_impl.imag#0","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._type_check_impl.imag#0","upper_bound":"builtins.object","values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0],"arg_names":["val"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"imag","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._RealT","id":-1,"name":"_RealT","namespace":"numpy.lib._type_check_impl.imag#1","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"uses_pep604_syntax":true},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0],"arg_names":["val"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"imag","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"iscomplex":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._type_check_impl.iscomplex","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.iscomplex","name":"iscomplex","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"iscomplex","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.iscomplex","name":"iscomplex","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"iscomplex","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.iscomplex","name":"iscomplex","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"iscomplex","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.iscomplex","name":"iscomplex","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"iscomplex","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.iscomplex","name":"iscomplex","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"iscomplex","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.iscomplex","name":"iscomplex","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"iscomplex","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"iscomplex","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"iscomplex","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"iscomplex","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"iscomplexobj":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._type_check_impl.iscomplexobj","name":"iscomplexobj","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"iscomplexobj","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isreal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._type_check_impl.isreal","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.isreal","name":"isreal","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isreal","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.isreal","name":"isreal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isreal","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.isreal","name":"isreal","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isreal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.isreal","name":"isreal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isreal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.isreal","name":"isreal","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isreal","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.isreal","name":"isreal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isreal","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isreal","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isreal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isreal","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"isrealobj":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._type_check_impl.isrealobj","name":"isrealobj","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasDType"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isrealobj","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"mintypecode":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["typechars","typeset","default"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._type_check_impl.mintypecode","name":"mintypecode","original_first_arg":"typechars","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["typechars","typeset","default"],"arg_types":[{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Container"}],"uses_pep604_syntax":true},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mintypecode","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"nan_to_num":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._type_check_impl.nan_to_num","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["x","copy","nan","posinf","neginf"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.nan_to_num","name":"nan_to_num","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["x","copy","nan","posinf","neginf"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._type_check_impl.nan_to_num#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"builtins.bool","builtins.float",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nan_to_num","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._type_check_impl.nan_to_num#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._type_check_impl.nan_to_num#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.nan_to_num","name":"nan_to_num","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["x","copy","nan","posinf","neginf"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._type_check_impl.nan_to_num#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"builtins.bool","builtins.float",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nan_to_num","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._type_check_impl.nan_to_num#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._type_check_impl.nan_to_num#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["x","copy","nan","posinf","neginf"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.nan_to_num","name":"nan_to_num","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["x","copy","nan","posinf","neginf"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},"builtins.bool","builtins.float",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nan_to_num","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._type_check_impl.nan_to_num#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.nan_to_num","name":"nan_to_num","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["x","copy","nan","posinf","neginf"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},"builtins.bool","builtins.float",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nan_to_num","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._type_check_impl.nan_to_num#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["x","copy","nan","posinf","neginf"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.nan_to_num","name":"nan_to_num","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["x","copy","nan","posinf","neginf"],"arg_types":[{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._type_check_impl.nan_to_num#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._array_like._SupportsArray"},"builtins.bool","builtins.float",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nan_to_num","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._type_check_impl.nan_to_num#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._type_check_impl.nan_to_num#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.nan_to_num","name":"nan_to_num","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["x","copy","nan","posinf","neginf"],"arg_types":[{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._type_check_impl.nan_to_num#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._array_like._SupportsArray"},"builtins.bool","builtins.float",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nan_to_num","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._type_check_impl.nan_to_num#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._type_check_impl.nan_to_num#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["x","copy","nan","posinf","neginf"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.nan_to_num","name":"nan_to_num","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["x","copy","nan","posinf","neginf"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},"builtins.bool","builtins.float",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nan_to_num","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.nan_to_num","name":"nan_to_num","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["x","copy","nan","posinf","neginf"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},"builtins.bool","builtins.float",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nan_to_num","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["x","copy","nan","posinf","neginf"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.nan_to_num","name":"nan_to_num","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["x","copy","nan","posinf","neginf"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.float",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nan_to_num","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.nan_to_num","name":"nan_to_num","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["x","copy","nan","posinf","neginf"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.float",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nan_to_num","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["x","copy","nan","posinf","neginf"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._type_check_impl.nan_to_num#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"builtins.bool","builtins.float",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nan_to_num","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._type_check_impl.nan_to_num#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._type_check_impl.nan_to_num#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["x","copy","nan","posinf","neginf"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"}],"uses_pep604_syntax":true},"builtins.bool","builtins.float",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nan_to_num","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._type_check_impl.nan_to_num#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["x","copy","nan","posinf","neginf"],"arg_types":[{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._type_check_impl.nan_to_num#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._array_like._SupportsArray"},"builtins.bool","builtins.float",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nan_to_num","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._type_check_impl.nan_to_num#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.lib._type_check_impl.nan_to_num#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["x","copy","nan","posinf","neginf"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy._typing._nested_sequence._NestedSequence"},"builtins.bool","builtins.float",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nan_to_num","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["x","copy","nan","posinf","neginf"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.float",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nan_to_num","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false},"real":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._type_check_impl.real","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["val"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.real","name":"real","original_first_arg":"val","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["val"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._type_check_impl.real#0","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasReal"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"real","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._type_check_impl.real#0","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._type_check_impl.real#0","upper_bound":"builtins.object","values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.real","name":"real","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["val"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._type_check_impl.real#0","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasReal"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"real","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._type_check_impl.real#0","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._type_check_impl.real#0","upper_bound":"builtins.object","values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["val"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.real","name":"real","original_first_arg":"val","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["val"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"real","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._RealT","id":-1,"name":"_RealT","namespace":"numpy.lib._type_check_impl.real#1","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"uses_pep604_syntax":true},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.real","name":"real","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["val"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"real","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._RealT","id":-1,"name":"_RealT","namespace":"numpy.lib._type_check_impl.real#1","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"uses_pep604_syntax":true},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["val"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.real","name":"real","original_first_arg":"val","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["val"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"real","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.real","name":"real","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["val"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"real","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["val"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._type_check_impl.real#0","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.lib._type_check_impl._HasReal"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"real","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._type_check_impl.real#0","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._T","id":-1,"name":"_T","namespace":"numpy.lib._type_check_impl.real#0","upper_bound":"builtins.object","values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0],"arg_names":["val"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"real","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._RealT","id":-1,"name":"_RealT","namespace":"numpy.lib._type_check_impl.real#1","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"uses_pep604_syntax":true},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0],"arg_names":["val"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"real","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"real_if_close":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._type_check_impl.real_if_close","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","tol"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.real_if_close","name":"real_if_close","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tol"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"real_if_close","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.real_if_close","name":"real_if_close","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tol"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"real_if_close","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","tol"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.real_if_close","name":"real_if_close","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tol"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"real_if_close","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.real_if_close","name":"real_if_close","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tol"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"real_if_close","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","tol"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.real_if_close","name":"real_if_close","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tol"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"real_if_close","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.real_if_close","name":"real_if_close","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tol"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"real_if_close","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","tol"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.real_if_close","name":"real_if_close","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tol"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"real_if_close","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._RealT","id":-1,"name":"_RealT","namespace":"numpy.lib._type_check_impl.real_if_close#3","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"uses_pep604_syntax":true},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.real_if_close","name":"real_if_close","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tol"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"real_if_close","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._RealT","id":-1,"name":"_RealT","namespace":"numpy.lib._type_check_impl.real_if_close#3","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"uses_pep604_syntax":true},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","tol"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.real_if_close","name":"real_if_close","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tol"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"real_if_close","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.real_if_close","name":"real_if_close","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tol"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"real_if_close","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tol"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"real_if_close","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tol"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"real_if_close","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tol"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"real_if_close","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tol"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"real_if_close","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._type_check_impl._RealT","id":-1,"name":"_RealT","namespace":"numpy.lib._type_check_impl.real_if_close#3","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"uses_pep604_syntax":true},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","tol"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"real_if_close","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"type_check_only":{".class":"SymbolTableNode","cross_ref":"typing.type_check_only","kind":"Gdef","module_hidden":true,"module_public":false},"typename":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._type_check_impl.typename","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["char"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","original_first_arg":"char","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"S1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"character"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"S1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"character"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["char"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","original_first_arg":"char","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"?"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"?"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["char"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","original_first_arg":"char","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"b"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"signed char"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"b"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"signed char"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["char"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","original_first_arg":"char","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"B"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"unsigned char"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"B"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"unsigned char"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["char"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","original_first_arg":"char","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"h"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"short"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"h"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"short"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["char"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","original_first_arg":"char","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"H"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"unsigned short"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"H"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"unsigned short"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["char"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","original_first_arg":"char","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"i"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"integer"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"i"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"integer"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["char"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","original_first_arg":"char","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"I"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"unsigned integer"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"I"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"unsigned integer"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["char"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","original_first_arg":"char","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"l"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"long integer"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"l"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"long integer"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["char"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","original_first_arg":"char","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"L"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"unsigned long integer"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"L"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"unsigned long integer"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["char"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","original_first_arg":"char","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"q"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"long long integer"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"q"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"long long integer"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["char"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","original_first_arg":"char","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"Q"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"unsigned long long integer"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"Q"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"unsigned long long integer"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["char"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","original_first_arg":"char","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"f"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"single precision"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"f"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"single precision"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["char"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","original_first_arg":"char","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"d"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"double precision"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"d"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"double precision"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["char"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","original_first_arg":"char","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"g"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"long precision"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"g"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"long precision"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["char"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","original_first_arg":"char","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"F"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"complex single precision"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"F"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"complex single precision"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["char"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","original_first_arg":"char","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"D"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"complex double precision"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"D"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"complex double precision"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["char"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","original_first_arg":"char","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"G"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"complex long double precision"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"G"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"complex long double precision"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["char"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","original_first_arg":"char","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"S"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"string"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"S"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"string"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["char"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","original_first_arg":"char","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"U"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"unicode"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"U"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"unicode"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["char"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","original_first_arg":"char","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"V"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"void"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"V"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"void"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["char"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","original_first_arg":"char","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"O"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"object"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._type_check_impl.typename","name":"typename","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"O"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"object"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"S1"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"character"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"?"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"b"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"signed char"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"B"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"unsigned char"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"h"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"short"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"H"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"unsigned short"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"i"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"integer"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"I"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"unsigned integer"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"l"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"long integer"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"L"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"unsigned long integer"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"q"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"long long integer"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"Q"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"unsigned long long integer"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"f"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"single precision"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"d"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"double precision"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"g"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"long precision"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"F"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"complex single precision"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"D"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"complex double precision"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"G"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"complex long double precision"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"S"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"string"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"U"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"unicode"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"V"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"void"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["char"],"arg_types":[{".class":"LiteralType","fallback":"builtins.str","value":"O"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"typename","ret_type":{".class":"LiteralType","fallback":"builtins.str","value":"object"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_type_check_impl.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_type_check_impl.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_type_check_impl.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..9fb10c4136f13fb45e6dcb8a4415364df5b50c08 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_type_check_impl.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,9,2,5,6,8,1,1,1,1,1,1],"dep_prios":[5,5,5,5,5,10,5,30,30,30,30,30],"dependencies":["collections.abc","numpy._typing","typing","_typeshed","typing_extensions","numpy","builtins","_frozen_importlib","abc","numpy._typing._array_like","numpy._typing._nbit_base","numpy._typing._nested_sequence"],"hash":"0337679028767e4a02a7caf9a293e2bba1c68138","id":"numpy.lib._type_check_impl","ignore_all":true,"interface_hash":"8ae1be9452cb5c0c01d915ced54b5f6043ab0cf0","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_type_check_impl.pyi","plugin_data":null,"size":9713,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_ufunclike_impl.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_ufunclike_impl.data.json new file mode 100644 index 0000000000000000000000000000000000000000..7eae0a390bcdcba8e8369ccddd3e2a0b6c5c2e81 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_ufunclike_impl.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.lib._ufunclike_impl","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeFloat_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeFloat_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeObject_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeObject_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._ufunclike_impl._ArrayT","name":"_ArrayT","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}},"_FloatLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._FloatLike_co","kind":"Gdef","module_hidden":true,"module_public":false},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib._ufunclike_impl.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._ufunclike_impl.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._ufunclike_impl.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._ufunclike_impl.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._ufunclike_impl.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._ufunclike_impl.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._ufunclike_impl.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"fix":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._ufunclike_impl.fix","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["x","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._ufunclike_impl.fix","name":"fix","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["x","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fix","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._ufunclike_impl.fix","name":"fix","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["x","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fix","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["x","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._ufunclike_impl.fix","name":"fix","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["x","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fix","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._ufunclike_impl.fix","name":"fix","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["x","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fix","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["x","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._ufunclike_impl.fix","name":"fix","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["x","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fix","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._ufunclike_impl.fix","name":"fix","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["x","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fix","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._ufunclike_impl.fix","name":"fix","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._ufunclike_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._ufunclike_impl.fix","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fix","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._ufunclike_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._ufunclike_impl.fix","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._ufunclike_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._ufunclike_impl.fix","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._ufunclike_impl.fix","name":"fix","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._ufunclike_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._ufunclike_impl.fix","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fix","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._ufunclike_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._ufunclike_impl.fix","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._ufunclike_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._ufunclike_impl.fix","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["x","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fix","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["x","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fix","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["x","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fix","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x","out"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._ufunclike_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._ufunclike_impl.fix","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fix","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._ufunclike_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._ufunclike_impl.fix","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._ufunclike_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._ufunclike_impl.fix","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}]}}},"floating":{".class":"SymbolTableNode","cross_ref":"numpy.floating","kind":"Gdef","module_hidden":true,"module_public":false},"isneginf":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._ufunclike_impl.isneginf","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["x","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._ufunclike_impl.isneginf","name":"isneginf","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["x","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isneginf","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._ufunclike_impl.isneginf","name":"isneginf","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["x","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isneginf","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["x","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._ufunclike_impl.isneginf","name":"isneginf","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["x","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isneginf","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._ufunclike_impl.isneginf","name":"isneginf","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["x","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isneginf","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._ufunclike_impl.isneginf","name":"isneginf","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._ufunclike_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._ufunclike_impl.isneginf","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isneginf","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._ufunclike_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._ufunclike_impl.isneginf","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._ufunclike_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._ufunclike_impl.isneginf","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._ufunclike_impl.isneginf","name":"isneginf","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._ufunclike_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._ufunclike_impl.isneginf","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isneginf","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._ufunclike_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._ufunclike_impl.isneginf","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._ufunclike_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._ufunclike_impl.isneginf","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["x","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isneginf","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["x","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isneginf","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._ufunclike_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._ufunclike_impl.isneginf","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isneginf","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._ufunclike_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._ufunclike_impl.isneginf","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._ufunclike_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._ufunclike_impl.isneginf","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}]}}},"isposinf":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.lib._ufunclike_impl.isposinf","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["x","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._ufunclike_impl.isposinf","name":"isposinf","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["x","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isposinf","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._ufunclike_impl.isposinf","name":"isposinf","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["x","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isposinf","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["x","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._ufunclike_impl.isposinf","name":"isposinf","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["x","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isposinf","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._ufunclike_impl.isposinf","name":"isposinf","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["x","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isposinf","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.lib._ufunclike_impl.isposinf","name":"isposinf","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._ufunclike_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._ufunclike_impl.isposinf","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isposinf","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._ufunclike_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._ufunclike_impl.isposinf","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._ufunclike_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._ufunclike_impl.isposinf","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.lib._ufunclike_impl.isposinf","name":"isposinf","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._ufunclike_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._ufunclike_impl.isposinf","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isposinf","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._ufunclike_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._ufunclike_impl.isposinf","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._ufunclike_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._ufunclike_impl.isposinf","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["x","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isposinf","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["x","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isposinf","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x","out"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._ufunclike_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._ufunclike_impl.isposinf","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isposinf","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._ufunclike_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._ufunclike_impl.isposinf","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._ufunclike_impl._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.lib._ufunclike_impl.isposinf","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}]}}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"object_":{".class":"SymbolTableNode","cross_ref":"numpy.object_","kind":"Gdef","module_hidden":true,"module_public":false},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_ufunclike_impl.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_ufunclike_impl.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_ufunclike_impl.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..d6fc015f04a71ffe5a00c52258a662fbb414b915 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_ufunclike_impl.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[5,1,3,1,1,1],"dep_prios":[5,5,5,5,30,30],"dependencies":["numpy._typing","typing","numpy","builtins","_frozen_importlib","abc"],"hash":"f91c52a9935d1a9dc566c2a1e9a4f3f298e07eb5","id":"numpy.lib._ufunclike_impl","ignore_all":true,"interface_hash":"bc02e645c8f802ec305f64db73f1944c8096c629","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_ufunclike_impl.pyi","plugin_data":null,"size":1288,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_utils_impl.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_utils_impl.data.json new file mode 100644 index 0000000000000000000000000000000000000000..085dfdc2884aa0f50010e803594e04c72bc29c95 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_utils_impl.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.lib._utils_impl","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","DTypeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like.DTypeLike","kind":"Gdef","module_hidden":true,"module_public":false},"SupportsWrite":{".class":"SymbolTableNode","cross_ref":"_typeshed.SupportsWrite","kind":"Gdef","module_hidden":true,"module_public":false},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib._utils_impl.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._utils_impl.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._utils_impl.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._utils_impl.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._utils_impl.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._utils_impl.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._utils_impl.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"drop_metadata":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._utils_impl.drop_metadata","name":"drop_metadata","original_first_arg":"dtype","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"drop_metadata","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_include":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._utils_impl.get_include","name":"get_include","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_include","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"info":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1,1,1,1],"arg_names":["object","maxwidth","output","toplevel"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._utils_impl.info","name":"info","original_first_arg":"object","type":{".class":"CallableType","arg_kinds":[1,1,1,1],"arg_names":["object","maxwidth","output","toplevel"],"arg_types":["builtins.object","builtins.int",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"_typeshed.SupportsWrite"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"info","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"show_runtime":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib._utils_impl.show_runtime","name":"show_runtime","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"show_runtime","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_utils_impl.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_utils_impl.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_utils_impl.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..24e1a0b4b1b21c84ddea91ed754bbe2845e72f37 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_utils_impl.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[3,1,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["numpy._typing","_typeshed","builtins","_frozen_importlib","abc","typing"],"hash":"951653f21a1019fecaecd28f4dd32fa195851ea2","id":"numpy.lib._utils_impl","ignore_all":true,"interface_hash":"946141d176aab3b27fd85873de60f28e66e65de0","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_utils_impl.pyi","plugin_data":null,"size":371,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_version.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_version.data.json new file mode 100644 index 0000000000000000000000000000000000000000..142e2d66e3263c280f6e2e4c062c1915735e89d6 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_version.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.lib._version","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","NumpyVersion":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.lib._version.NumpyVersion","name":"NumpyVersion","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.lib._version.NumpyVersion","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.lib._version","mro":["numpy.lib._version.NumpyVersion","builtins.object"],"names":{".class":"SymbolTable","__eq__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._version.NumpyVersion.__eq__","name":"__eq__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib._version.NumpyVersion",{".class":"UnionType","items":["builtins.str","numpy.lib._version.NumpyVersion"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__eq__ of NumpyVersion","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__ge__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._version.NumpyVersion.__ge__","name":"__ge__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib._version.NumpyVersion",{".class":"UnionType","items":["builtins.str","numpy.lib._version.NumpyVersion"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ge__ of NumpyVersion","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__gt__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._version.NumpyVersion.__gt__","name":"__gt__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib._version.NumpyVersion",{".class":"UnionType","items":["builtins.str","numpy.lib._version.NumpyVersion"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__gt__ of NumpyVersion","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","vstring"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._version.NumpyVersion.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","vstring"],"arg_types":["numpy.lib._version.NumpyVersion","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of NumpyVersion","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__le__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._version.NumpyVersion.__le__","name":"__le__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib._version.NumpyVersion",{".class":"UnionType","items":["builtins.str","numpy.lib._version.NumpyVersion"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__le__ of NumpyVersion","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__lt__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._version.NumpyVersion.__lt__","name":"__lt__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib._version.NumpyVersion",{".class":"UnionType","items":["builtins.str","numpy.lib._version.NumpyVersion"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__lt__ of NumpyVersion","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__ne__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib._version.NumpyVersion.__ne__","name":"__ne__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib._version.NumpyVersion",{".class":"UnionType","items":["builtins.str","numpy.lib._version.NumpyVersion"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ne__ of NumpyVersion","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"bugfix":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._version.NumpyVersion.bugfix","name":"bugfix","setter_type":null,"type":"builtins.int"}},"is_devversion":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._version.NumpyVersion.is_devversion","name":"is_devversion","setter_type":null,"type":"builtins.bool"}},"major":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._version.NumpyVersion.major","name":"major","setter_type":null,"type":"builtins.int"}},"minor":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._version.NumpyVersion.minor","name":"minor","setter_type":null,"type":"builtins.int"}},"pre_release":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._version.NumpyVersion.pre_release","name":"pre_release","setter_type":null,"type":"builtins.str"}},"version":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._version.NumpyVersion.version","name":"version","setter_type":null,"type":"builtins.str"}},"vstring":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.lib._version.NumpyVersion.vstring","name":"vstring","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib._version.NumpyVersion.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.lib._version.NumpyVersion","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib._version.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._version.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._version.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._version.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._version.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._version.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib._version.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_version.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_version.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_version.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..3cd50bc2e74e57104fafc99cb76adfbe3e15426e --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/_version.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106713,"dep_lines":[1,1,1,1],"dep_prios":[5,30,30,30],"dependencies":["builtins","_frozen_importlib","abc","typing"],"hash":"5f08b5976b6ccb1853c2e218e1f43f6b25607c2d","id":"numpy.lib._version","ignore_all":true,"interface_hash":"851ed38c95cb888f3846138c46bae286ce20c7d4","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/_version.pyi","plugin_data":null,"size":641,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/array_utils.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/array_utils.data.json new file mode 100644 index 0000000000000000000000000000000000000000..f8d0e7c88bc9b3780a7397e513909c2cdcbc0b57 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/array_utils.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.lib.array_utils","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","__all__":{".class":"SymbolTableNode","cross_ref":"numpy.lib._array_utils_impl.__all__","kind":"Gdef","module_public":false},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.array_utils.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.array_utils.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.array_utils.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.array_utils.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.array_utils.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.array_utils.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"byte_bounds":{".class":"SymbolTableNode","cross_ref":"numpy.lib._array_utils_impl.byte_bounds","kind":"Gdef"},"normalize_axis_index":{".class":"SymbolTableNode","cross_ref":"numpy.lib._array_utils_impl.normalize_axis_index","kind":"Gdef"},"normalize_axis_tuple":{".class":"SymbolTableNode","cross_ref":"numpy.lib._array_utils_impl.normalize_axis_tuple","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/array_utils.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/array_utils.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/array_utils.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..13bd2dc1db3d3891401f0058b25974c68cabe424 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/array_utils.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,1,1,1,1],"dep_prios":[5,5,30,30,30],"dependencies":["numpy.lib._array_utils_impl","builtins","_frozen_importlib","abc","typing"],"hash":"1ea1c6758b49acb8f52e59d3ddebd51d05a0142f","id":"numpy.lib.array_utils","ignore_all":true,"interface_hash":"e15887e75d1871c53e7e08cdc95be495e986eada","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/array_utils.pyi","plugin_data":null,"size":296,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/format.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/format.data.json new file mode 100644 index 0000000000000000000000000000000000000000..b828dec6bda9d301bdf367a31baf6ef67ee9e13c --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/format.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.lib.format","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","ARRAY_ALIGN":{".class":"SymbolTableNode","cross_ref":"numpy.lib._format_impl.ARRAY_ALIGN","kind":"Gdef","module_public":false},"BUFFER_SIZE":{".class":"SymbolTableNode","cross_ref":"numpy.lib._format_impl.BUFFER_SIZE","kind":"Gdef","module_public":false},"EXPECTED_KEYS":{".class":"SymbolTableNode","cross_ref":"numpy.lib._format_impl.EXPECTED_KEYS","kind":"Gdef","module_public":false},"GROWTH_AXIS_MAX_DIGITS":{".class":"SymbolTableNode","cross_ref":"numpy.lib._format_impl.GROWTH_AXIS_MAX_DIGITS","kind":"Gdef","module_public":false},"MAGIC_LEN":{".class":"SymbolTableNode","cross_ref":"numpy.lib._format_impl.MAGIC_LEN","kind":"Gdef","module_public":false},"MAGIC_PREFIX":{".class":"SymbolTableNode","cross_ref":"numpy.lib._format_impl.MAGIC_PREFIX","kind":"Gdef","module_public":false},"__all__":{".class":"SymbolTableNode","cross_ref":"numpy.lib._format_impl.__all__","kind":"Gdef","module_public":false},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.format.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.format.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.format.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.format.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.format.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.format.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"descr_to_dtype":{".class":"SymbolTableNode","cross_ref":"numpy.lib._format_impl.descr_to_dtype","kind":"Gdef","module_public":false},"drop_metadata":{".class":"SymbolTableNode","cross_ref":"numpy.lib._utils_impl.drop_metadata","kind":"Gdef","module_public":false},"dtype_to_descr":{".class":"SymbolTableNode","cross_ref":"numpy.lib._format_impl.dtype_to_descr","kind":"Gdef","module_public":false},"header_data_from_array_1_0":{".class":"SymbolTableNode","cross_ref":"numpy.lib._format_impl.header_data_from_array_1_0","kind":"Gdef","module_public":false},"isfileobj":{".class":"SymbolTableNode","cross_ref":"numpy.lib._format_impl.isfileobj","kind":"Gdef","module_public":false},"magic":{".class":"SymbolTableNode","cross_ref":"numpy.lib._format_impl.magic","kind":"Gdef","module_public":false},"open_memmap":{".class":"SymbolTableNode","cross_ref":"numpy.lib._format_impl.open_memmap","kind":"Gdef","module_public":false},"read_array":{".class":"SymbolTableNode","cross_ref":"numpy.lib._format_impl.read_array","kind":"Gdef","module_public":false},"read_array_header_1_0":{".class":"SymbolTableNode","cross_ref":"numpy.lib._format_impl.read_array_header_1_0","kind":"Gdef","module_public":false},"read_array_header_2_0":{".class":"SymbolTableNode","cross_ref":"numpy.lib._format_impl.read_array_header_2_0","kind":"Gdef","module_public":false},"read_magic":{".class":"SymbolTableNode","cross_ref":"numpy.lib._format_impl.read_magic","kind":"Gdef","module_public":false},"write_array":{".class":"SymbolTableNode","cross_ref":"numpy.lib._format_impl.write_array","kind":"Gdef","module_public":false},"write_array_header_1_0":{".class":"SymbolTableNode","cross_ref":"numpy.lib._format_impl.write_array_header_1_0","kind":"Gdef","module_public":false},"write_array_header_2_0":{".class":"SymbolTableNode","cross_ref":"numpy.lib._format_impl.write_array_header_2_0","kind":"Gdef","module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/format.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/format.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/format.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..9aa6e2be3fc2c2ca37e4bd1cc958d7df540a0362 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/format.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,1,1,1,1],"dep_prios":[5,5,30,30,30],"dependencies":["numpy.lib._format_impl","builtins","_frozen_importlib","abc","typing"],"hash":"9d259e8de70b6a1ad2bedc277d95d8ae4503a4f9","id":"numpy.lib.format","ignore_all":true,"interface_hash":"d85fb42f997ac7fba27dc2dae916c7d4bfc5a457","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/format.pyi","plugin_data":null,"size":1482,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/introspect.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/introspect.data.json new file mode 100644 index 0000000000000000000000000000000000000000..8099d77921845c582debf0618dc6196b9c869b2c --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/introspect.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.lib.introspect","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib.introspect.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.introspect.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.introspect.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.introspect.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.introspect.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.introspect.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.introspect.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"opt_func_info":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1,1],"arg_names":["func_name","signature"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.lib.introspect.opt_func_info","name":"opt_func_info","original_first_arg":"func_name","type":{".class":"CallableType","arg_kinds":[1,1],"arg_names":["func_name","signature"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"opt_func_info","ret_type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}],"extra_attrs":null,"type_ref":"builtins.dict"}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/introspect.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/introspect.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/introspect.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..20ec64187bfc79ec09f295f88e3fd7c1425e10da --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/introspect.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106713,"dep_lines":[1,1,1,1],"dep_prios":[5,30,30,30],"dependencies":["builtins","_frozen_importlib","abc","typing"],"hash":"76a92116a63826d3c0447eb4cfd3cc93e4ceca84","id":"numpy.lib.introspect","ignore_all":true,"interface_hash":"7b161cfcb1b8ca988a274194c7bf5437926a6d6f","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/introspect.pyi","plugin_data":null,"size":152,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/mixins.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/mixins.data.json new file mode 100644 index 0000000000000000000000000000000000000000..839db1e300bf32dc1aa5ef40ac921a9060239680 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/mixins.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.lib.mixins","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","ABC":{".class":"SymbolTableNode","cross_ref":"abc.ABC","kind":"Gdef","module_hidden":true,"module_public":false},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"L":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"NDArrayOperatorsMixin":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[["__array_ufunc__",1]],"alt_promote":null,"bases":["abc.ABC"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.lib.mixins.NDArrayOperatorsMixin","name":"NDArrayOperatorsMixin","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_abstract"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.lib.mixins","mro":["numpy.lib.mixins.NDArrayOperatorsMixin","abc.ABC","builtins.object"],"names":{".class":"SymbolTable","__abs__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__abs__","name":"__abs__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__abs__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__add__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__add__","name":"__add__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__add__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__and__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__and__","name":"__and__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__and__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__array_ufunc__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":1,"arg_kinds":[0,0,0,2,4],"arg_names":["self","ufunc","method","inputs","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated","is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__array_ufunc__","name":"__array_ufunc__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,2,4],"arg_names":["self","ufunc","method","inputs","kwargs"],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin","numpy.ufunc",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"__call__"},{".class":"LiteralType","fallback":"builtins.str","value":"reduce"},{".class":"LiteralType","fallback":"builtins.str","value":"reduceat"},{".class":"LiteralType","fallback":"builtins.str","value":"accumulate"},{".class":"LiteralType","fallback":"builtins.str","value":"outer"},{".class":"LiteralType","fallback":"builtins.str","value":"at"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__array_ufunc__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__array_ufunc__","name":"__array_ufunc__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,2,4],"arg_names":["self","ufunc","method","inputs","kwargs"],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin","numpy.ufunc",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"__call__"},{".class":"LiteralType","fallback":"builtins.str","value":"reduce"},{".class":"LiteralType","fallback":"builtins.str","value":"reduceat"},{".class":"LiteralType","fallback":"builtins.str","value":"accumulate"},{".class":"LiteralType","fallback":"builtins.str","value":"outer"},{".class":"LiteralType","fallback":"builtins.str","value":"at"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__array_ufunc__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__divmod__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__divmod__","name":"__divmod__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__divmod__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__eq__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__eq__","name":"__eq__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__eq__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__floordiv__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__floordiv__","name":"__floordiv__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__floordiv__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__ge__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__ge__","name":"__ge__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ge__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__gt__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__gt__","name":"__gt__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__gt__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__iadd__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__iadd__","name":"__iadd__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iadd__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__iand__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__iand__","name":"__iand__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iand__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__ifloordiv__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__ifloordiv__","name":"__ifloordiv__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ifloordiv__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__ilshift__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__ilshift__","name":"__ilshift__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ilshift__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__imatmul__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__imatmul__","name":"__imatmul__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__imatmul__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__imod__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__imod__","name":"__imod__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__imod__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__imul__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__imul__","name":"__imul__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__imul__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__invert__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__invert__","name":"__invert__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__invert__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__ior__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__ior__","name":"__ior__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ior__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__ipow__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__ipow__","name":"__ipow__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ipow__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__irshift__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__irshift__","name":"__irshift__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__irshift__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__isub__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__isub__","name":"__isub__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__isub__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__itruediv__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__itruediv__","name":"__itruediv__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__itruediv__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__ixor__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__ixor__","name":"__ixor__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ixor__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__le__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__le__","name":"__le__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__le__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__lshift__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__lshift__","name":"__lshift__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__lshift__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__lt__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__lt__","name":"__lt__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__lt__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__matmul__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__matmul__","name":"__matmul__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__matmul__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__mod__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__mod__","name":"__mod__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mod__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__mul__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__mul__","name":"__mul__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mul__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__ne__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__ne__","name":"__ne__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ne__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__neg__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__neg__","name":"__neg__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__neg__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__or__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__or__","name":"__or__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__or__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__pos__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__pos__","name":"__pos__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__pos__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__pow__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__pow__","name":"__pow__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__pow__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__radd__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__radd__","name":"__radd__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__radd__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__rand__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__rand__","name":"__rand__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__rand__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__rdivmod__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","other"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__rdivmod__","name":"__rdivmod__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","other"],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__rdivmod__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__rfloordiv__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__rfloordiv__","name":"__rfloordiv__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__rfloordiv__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__rlshift__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__rlshift__","name":"__rlshift__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__rlshift__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__rmatmul__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__rmatmul__","name":"__rmatmul__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__rmatmul__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__rmod__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__rmod__","name":"__rmod__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__rmod__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__rmul__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__rmul__","name":"__rmul__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__rmul__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__ror__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__ror__","name":"__ror__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ror__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__rpow__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__rpow__","name":"__rpow__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__rpow__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__rrshift__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__rrshift__","name":"__rrshift__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__rrshift__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__rshift__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__rshift__","name":"__rshift__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__rshift__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__rsub__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__rsub__","name":"__rsub__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__rsub__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__rtruediv__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__rtruediv__","name":"__rtruediv__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__rtruediv__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__rxor__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__rxor__","name":"__rxor__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__rxor__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"__sub__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__sub__","name":"__sub__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__sub__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__truediv__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__truediv__","name":"__truediv__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__truediv__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__xor__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.__xor__","name":"__xor__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.lib.mixins.NDArrayOperatorsMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__xor__ of NDArrayOperatorsMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.lib.mixins.NDArrayOperatorsMixin.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.lib.mixins.NDArrayOperatorsMixin","values":[],"variance":0},"slots":[],"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.lib.mixins.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.mixins.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.mixins.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.mixins.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.mixins.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.mixins.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.mixins.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"abstractmethod":{".class":"SymbolTableNode","cross_ref":"abc.abstractmethod","kind":"Gdef","module_hidden":true,"module_public":false},"ufunc":{".class":"SymbolTableNode","cross_ref":"numpy.ufunc","kind":"Gdef","module_hidden":true,"module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/mixins.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/mixins.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/mixins.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..ed109e69b68bce98a94a1cb3e10a83952ad8322b --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/mixins.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,2,5,1,1],"dep_prios":[5,5,5,5,30],"dependencies":["abc","typing","numpy","builtins","_frozen_importlib"],"hash":"44e61ba2a15110b90cf2eb49ebef9f29121cfb21","id":"numpy.lib.mixins","ignore_all":true,"interface_hash":"918ddcc8f13101febdc8cc2df408710d6862781f","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/mixins.pyi","plugin_data":null,"size":3151,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/npyio.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/npyio.data.json new file mode 100644 index 0000000000000000000000000000000000000000..15435dba783b136c226a32e599b01cf8a961ad5c --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/npyio.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.lib.npyio","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","DataSource":{".class":"SymbolTableNode","cross_ref":"numpy.lib._datasource.DataSource","kind":"Gdef"},"NpzFile":{".class":"SymbolTableNode","cross_ref":"numpy.lib._npyio_impl.NpzFile","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.npyio.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.npyio.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.npyio.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.npyio.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.npyio.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.npyio.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/npyio.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/npyio.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/npyio.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..e9fc22e25cdbb3ea410404bca2d748355bb83939 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/npyio.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,1,1,1,1],"dep_prios":[5,5,30,30,30],"dependencies":["numpy.lib._npyio_impl","builtins","_frozen_importlib","abc","typing"],"hash":"ea15e34d7169b44dac079003b448bf9c7616d0d4","id":"numpy.lib.npyio","ignore_all":true,"interface_hash":"728b6918e079ebf9804067a3c27ac373e3ef5b38","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/npyio.pyi","plugin_data":null,"size":192,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/scimath.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/scimath.data.json new file mode 100644 index 0000000000000000000000000000000000000000..f6fd56716a6f498e23cef5fecc52ff47a2b486bc --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/scimath.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.lib.scimath","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","__all__":{".class":"SymbolTableNode","cross_ref":"numpy.lib._scimath_impl.__all__","kind":"Gdef","module_public":false},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.scimath.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.scimath.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.scimath.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.scimath.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.scimath.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.scimath.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"arccos":{".class":"SymbolTableNode","cross_ref":"numpy.lib._scimath_impl.arccos","kind":"Gdef"},"arcsin":{".class":"SymbolTableNode","cross_ref":"numpy.lib._scimath_impl.arcsin","kind":"Gdef"},"arctanh":{".class":"SymbolTableNode","cross_ref":"numpy.lib._scimath_impl.arctanh","kind":"Gdef"},"log":{".class":"SymbolTableNode","cross_ref":"numpy.lib._scimath_impl.log","kind":"Gdef"},"log10":{".class":"SymbolTableNode","cross_ref":"numpy.lib._scimath_impl.log10","kind":"Gdef"},"log2":{".class":"SymbolTableNode","cross_ref":"numpy.lib._scimath_impl.log2","kind":"Gdef"},"logn":{".class":"SymbolTableNode","cross_ref":"numpy.lib._scimath_impl.logn","kind":"Gdef"},"power":{".class":"SymbolTableNode","cross_ref":"numpy.lib._scimath_impl.power","kind":"Gdef"},"sqrt":{".class":"SymbolTableNode","cross_ref":"numpy.lib._scimath_impl.sqrt","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/scimath.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/scimath.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/scimath.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..11d109f46ab50f9c9beae3d15c73bb34fbb052e0 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/scimath.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,1,1,1,1],"dep_prios":[5,5,30,30,30],"dependencies":["numpy.lib._scimath_impl","builtins","_frozen_importlib","abc","typing"],"hash":"d5a058a6204b882f90aae577faaa0be03a3cce8c","id":"numpy.lib.scimath","ignore_all":true,"interface_hash":"8ee9119ac92067545934d7862e61c9326d3349d7","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/scimath.pyi","plugin_data":null,"size":512,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/stride_tricks.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/stride_tricks.data.json new file mode 100644 index 0000000000000000000000000000000000000000..f0a3c29c0e020518c7ab468c1ef119f0a2009411 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/stride_tricks.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.lib.stride_tricks","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.stride_tricks.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.stride_tricks.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.stride_tricks.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.stride_tricks.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.stride_tricks.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.lib.stride_tricks.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"as_strided":{".class":"SymbolTableNode","cross_ref":"numpy.lib._stride_tricks_impl.as_strided","kind":"Gdef"},"sliding_window_view":{".class":"SymbolTableNode","cross_ref":"numpy.lib._stride_tricks_impl.sliding_window_view","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/stride_tricks.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/stride_tricks.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/stride_tricks.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..5a112ca035f4a42a01d0e576a5d0863eb6fc2f9c --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/lib/stride_tricks.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,1,1,1,1],"dep_prios":[5,5,30,30,30],"dependencies":["numpy.lib._stride_tricks_impl","builtins","_frozen_importlib","abc","typing"],"hash":"d64e97e8fa547e3db455d49905a905561e66232c","id":"numpy.lib.stride_tricks","ignore_all":true,"interface_hash":"9b5d74de0b29760331d379269be223e8549d6f8b","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/lib/stride_tricks.pyi","plugin_data":null,"size":170,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/linalg/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/linalg/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..9a0cd58464bb268162a67786d345ad3349a3f56b --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/linalg/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.linalg","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","LinAlgError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.ValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.linalg.LinAlgError","name":"LinAlgError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.linalg.LinAlgError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.linalg","mro":["numpy.linalg.LinAlgError","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg.LinAlgError.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.linalg.LinAlgError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.linalg.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.linalg.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.linalg.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.linalg.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.linalg.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.linalg.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.linalg.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.linalg.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_linalg":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg","kind":"Gdef","module_public":false},"_umath_linalg":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._umath_linalg","kind":"Gdef","module_public":false},"cholesky":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.cholesky","kind":"Gdef"},"cond":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.cond","kind":"Gdef"},"cross":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.cross","kind":"Gdef"},"det":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.det","kind":"Gdef"},"diagonal":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.diagonal","kind":"Gdef"},"eig":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.eig","kind":"Gdef"},"eigh":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.eigh","kind":"Gdef"},"eigvals":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.eigvals","kind":"Gdef"},"eigvalsh":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.eigvalsh","kind":"Gdef"},"inv":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.inv","kind":"Gdef"},"linalg":{".class":"SymbolTableNode","cross_ref":"numpy.linalg.linalg","kind":"Gdef","module_public":false},"lstsq":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.lstsq","kind":"Gdef"},"matmul":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.matmul","kind":"Gdef"},"matrix_norm":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.matrix_norm","kind":"Gdef"},"matrix_power":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.matrix_power","kind":"Gdef"},"matrix_rank":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.matrix_rank","kind":"Gdef"},"matrix_transpose":{".class":"SymbolTableNode","cross_ref":"numpy._core.fromnumeric.matrix_transpose","kind":"Gdef"},"multi_dot":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.multi_dot","kind":"Gdef"},"norm":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.norm","kind":"Gdef"},"outer":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.outer","kind":"Gdef"},"pinv":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.pinv","kind":"Gdef"},"qr":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.qr","kind":"Gdef"},"slogdet":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.slogdet","kind":"Gdef"},"solve":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.solve","kind":"Gdef"},"svd":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.svd","kind":"Gdef"},"svdvals":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.svdvals","kind":"Gdef"},"tensordot":{".class":"SymbolTableNode","cross_ref":"numpy._core.numeric.tensordot","kind":"Gdef"},"tensorinv":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.tensorinv","kind":"Gdef"},"tensorsolve":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.tensorsolve","kind":"Gdef"},"trace":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.trace","kind":"Gdef"},"vecdot":{".class":"SymbolTableNode","cross_ref":"numpy.vecdot","kind":"Gdef"},"vector_norm":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.vector_norm","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/linalg/__init__.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/linalg/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/linalg/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..61c4a728018db01b4c04ab0491a60c35ab25eedc --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/linalg/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,2,3,1,1,1,1],"dep_prios":[5,10,10,5,30,30,30],"dependencies":["numpy.linalg._linalg","numpy.linalg._umath_linalg","numpy.linalg.linalg","builtins","_frozen_importlib","abc","typing"],"hash":"c686c84e5196ae4af1be6e9a8eece16fb3b7919d","id":"numpy.linalg","ignore_all":true,"interface_hash":"6478435f1214a18b64083168a4b3ddd86d38207d","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/linalg/__init__.pyi","plugin_data":null,"size":1060,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/linalg/_linalg.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/linalg/_linalg.data.json new file mode 100644 index 0000000000000000000000000000000000000000..9857e564e502bced7afd7ae15a636dafd42e247d --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/linalg/_linalg.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.linalg._linalg","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"DTypeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like.DTypeLike","kind":"Gdef","module_hidden":true,"module_public":false},"EigResult":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.linalg._linalg.EigResult","name":"EigResult","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_named_tuple"],"fullname":"numpy.linalg._linalg.EigResult","has_param_spec_type":false,"metaclass_type":null,"metadata":{"namedtuple":{"fields":["eigenvalues","eigenvectors"]}},"module_name":"numpy.linalg._linalg","mro":["numpy.linalg._linalg.EigResult","builtins.tuple","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","_NT":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.EigResult._NT","name":"_NT","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},"__annotations__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.linalg._linalg.EigResult.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.linalg._linalg.EigResult.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__new__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["_cls","eigenvalues","eigenvectors"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static"],"fullname":"numpy.linalg._linalg.EigResult.__new__","name":"__new__","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["_cls","eigenvalues","eigenvectors"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.EigResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.EigResult.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of EigResult","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.EigResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.EigResult.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.EigResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.EigResult.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_asdict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["_self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.EigResult._asdict","name":"_asdict","original_first_arg":"_self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["_self"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.EigResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.EigResult._asdict","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_asdict of EigResult","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.EigResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.EigResult._asdict","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_field_defaults":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.linalg._linalg.EigResult._field_defaults","name":"_field_defaults","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_field_types":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.linalg._linalg.EigResult._field_types","name":"_field_types","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_fields":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.linalg._linalg.EigResult._fields","name":"_fields","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_make":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["_cls","iterable"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated"],"fullname":"numpy.linalg._linalg.EigResult._make","name":"_make","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["_cls","iterable"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.EigResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.EigResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_make of EigResult","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.EigResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.EigResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.EigResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.EigResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_classmethod","is_ready"],"fullname":"numpy.linalg._linalg.EigResult._make","name":"_make","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["_cls","iterable"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.EigResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.EigResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_make of EigResult","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.EigResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.EigResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.EigResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.EigResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}}},"plugin_generated":true},"_replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5],"arg_names":["_self","eigenvalues","eigenvectors"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.EigResult._replace","name":"_replace","original_first_arg":"_self","type":{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":["_self","eigenvalues","eigenvectors"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.EigResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.EigResult._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_replace of EigResult","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.EigResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.EigResult._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.EigResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.EigResult._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_source":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.linalg._linalg.EigResult._source","name":"_source","setter_type":null,"type":"builtins.str"}},"eigenvalues":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"numpy.linalg._linalg.EigResult.eigenvalues","name":"eigenvalues","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"eigenvalues-redefinition":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.EigResult.eigenvalues","kind":"Mdef"},"eigenvectors":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"numpy.linalg._linalg.EigResult.eigenvectors","name":"eigenvectors","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"eigenvectors-redefinition":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.EigResult.eigenvectors","kind":"Mdef"}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.EigResult.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":"numpy.linalg._linalg.EigResult"},"values":[],"variance":0},"slots":null,"tuple_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_vars":[],"typeddict_type":null}},"EighResult":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.linalg._linalg.EighResult","name":"EighResult","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_named_tuple"],"fullname":"numpy.linalg._linalg.EighResult","has_param_spec_type":false,"metaclass_type":null,"metadata":{"namedtuple":{"fields":["eigenvalues","eigenvectors"]}},"module_name":"numpy.linalg._linalg","mro":["numpy.linalg._linalg.EighResult","builtins.tuple","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","_NT":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.EighResult._NT","name":"_NT","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},"__annotations__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.linalg._linalg.EighResult.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.linalg._linalg.EighResult.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__new__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["_cls","eigenvalues","eigenvectors"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static"],"fullname":"numpy.linalg._linalg.EighResult.__new__","name":"__new__","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["_cls","eigenvalues","eigenvectors"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.EighResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.EighResult.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of EighResult","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.EighResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.EighResult.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.EighResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.EighResult.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_asdict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["_self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.EighResult._asdict","name":"_asdict","original_first_arg":"_self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["_self"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.EighResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.EighResult._asdict","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_asdict of EighResult","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.EighResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.EighResult._asdict","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_field_defaults":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.linalg._linalg.EighResult._field_defaults","name":"_field_defaults","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_field_types":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.linalg._linalg.EighResult._field_types","name":"_field_types","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_fields":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.linalg._linalg.EighResult._fields","name":"_fields","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_make":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["_cls","iterable"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated"],"fullname":"numpy.linalg._linalg.EighResult._make","name":"_make","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["_cls","iterable"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.EighResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.EighResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_make of EighResult","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.EighResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.EighResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.EighResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.EighResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_classmethod","is_ready"],"fullname":"numpy.linalg._linalg.EighResult._make","name":"_make","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["_cls","iterable"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.EighResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.EighResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_make of EighResult","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.EighResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.EighResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.EighResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.EighResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}}},"plugin_generated":true},"_replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5],"arg_names":["_self","eigenvalues","eigenvectors"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.EighResult._replace","name":"_replace","original_first_arg":"_self","type":{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":["_self","eigenvalues","eigenvectors"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.EighResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.EighResult._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_replace of EighResult","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.EighResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.EighResult._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.EighResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.EighResult._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_source":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.linalg._linalg.EighResult._source","name":"_source","setter_type":null,"type":"builtins.str"}},"eigenvalues":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"numpy.linalg._linalg.EighResult.eigenvalues","name":"eigenvalues","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"eigenvalues-redefinition":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.EighResult.eigenvalues","kind":"Mdef"},"eigenvectors":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"numpy.linalg._linalg.EighResult.eigenvectors","name":"eigenvectors","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"eigenvectors-redefinition":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.EighResult.eigenvectors","kind":"Mdef"}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.EighResult.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":"numpy.linalg._linalg.EighResult"},"values":[],"variance":0},"slots":null,"tuple_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_vars":[],"typeddict_type":null}},"Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef","module_hidden":true,"module_public":false},"L":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"LinAlgError":{".class":"SymbolTableNode","cross_ref":"numpy.linalg.LinAlgError","kind":"Gdef"},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"NamedTuple":{".class":"SymbolTableNode","cross_ref":"typing.NamedTuple","kind":"Gdef","module_hidden":true,"module_public":false},"Never":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.Never","name":"Never","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.linalg._linalg.Never","source_any":null,"type_of_any":3}}},"QRResult":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.linalg._linalg.QRResult","name":"QRResult","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_named_tuple"],"fullname":"numpy.linalg._linalg.QRResult","has_param_spec_type":false,"metaclass_type":null,"metadata":{"namedtuple":{"fields":["Q","R"]}},"module_name":"numpy.linalg._linalg","mro":["numpy.linalg._linalg.QRResult","builtins.tuple","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","Q":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"numpy.linalg._linalg.QRResult.Q","name":"Q","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"Q-redefinition":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.QRResult.Q","kind":"Mdef"},"R":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"numpy.linalg._linalg.QRResult.R","name":"R","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"R-redefinition":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.QRResult.R","kind":"Mdef"},"_NT":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.QRResult._NT","name":"_NT","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},"__annotations__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.linalg._linalg.QRResult.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.linalg._linalg.QRResult.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__new__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["_cls","Q","R"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static"],"fullname":"numpy.linalg._linalg.QRResult.__new__","name":"__new__","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["_cls","Q","R"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.QRResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.QRResult.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of QRResult","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.QRResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.QRResult.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.QRResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.QRResult.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_asdict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["_self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.QRResult._asdict","name":"_asdict","original_first_arg":"_self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["_self"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.QRResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.QRResult._asdict","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_asdict of QRResult","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.QRResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.QRResult._asdict","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_field_defaults":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.linalg._linalg.QRResult._field_defaults","name":"_field_defaults","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_field_types":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.linalg._linalg.QRResult._field_types","name":"_field_types","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_fields":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.linalg._linalg.QRResult._fields","name":"_fields","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_make":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["_cls","iterable"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated"],"fullname":"numpy.linalg._linalg.QRResult._make","name":"_make","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["_cls","iterable"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.QRResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.QRResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_make of QRResult","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.QRResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.QRResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.QRResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.QRResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_classmethod","is_ready"],"fullname":"numpy.linalg._linalg.QRResult._make","name":"_make","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["_cls","iterable"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.QRResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.QRResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_make of QRResult","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.QRResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.QRResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.QRResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.QRResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}}},"plugin_generated":true},"_replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5],"arg_names":["_self","Q","R"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.QRResult._replace","name":"_replace","original_first_arg":"_self","type":{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":["_self","Q","R"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.QRResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.QRResult._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_replace of QRResult","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.QRResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.QRResult._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.QRResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.QRResult._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_source":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.linalg._linalg.QRResult._source","name":"_source","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.QRResult.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":"numpy.linalg._linalg.QRResult"},"values":[],"variance":0},"slots":null,"tuple_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_vars":[],"typeddict_type":null}},"SVDResult":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.linalg._linalg.SVDResult","name":"SVDResult","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_named_tuple"],"fullname":"numpy.linalg._linalg.SVDResult","has_param_spec_type":false,"metaclass_type":null,"metadata":{"namedtuple":{"fields":["U","S","Vh"]}},"module_name":"numpy.linalg._linalg","mro":["numpy.linalg._linalg.SVDResult","builtins.tuple","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","S":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"numpy.linalg._linalg.SVDResult.S","name":"S","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"S-redefinition":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.SVDResult.S","kind":"Mdef"},"U":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"numpy.linalg._linalg.SVDResult.U","name":"U","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"U-redefinition":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.SVDResult.U","kind":"Mdef"},"Vh":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"numpy.linalg._linalg.SVDResult.Vh","name":"Vh","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"Vh-redefinition":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.SVDResult.Vh","kind":"Mdef"},"_NT":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.SVDResult._NT","name":"_NT","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},"__annotations__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.linalg._linalg.SVDResult.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.linalg._linalg.SVDResult.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__new__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["_cls","U","S","Vh"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static"],"fullname":"numpy.linalg._linalg.SVDResult.__new__","name":"__new__","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["_cls","U","S","Vh"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.SVDResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.SVDResult.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of SVDResult","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.SVDResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.SVDResult.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.SVDResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.SVDResult.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_asdict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["_self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.SVDResult._asdict","name":"_asdict","original_first_arg":"_self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["_self"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.SVDResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.SVDResult._asdict","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_asdict of SVDResult","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.SVDResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.SVDResult._asdict","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_field_defaults":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.linalg._linalg.SVDResult._field_defaults","name":"_field_defaults","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_field_types":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.linalg._linalg.SVDResult._field_types","name":"_field_types","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_fields":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.linalg._linalg.SVDResult._fields","name":"_fields","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_make":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["_cls","iterable"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated"],"fullname":"numpy.linalg._linalg.SVDResult._make","name":"_make","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["_cls","iterable"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.SVDResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.SVDResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_make of SVDResult","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.SVDResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.SVDResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.SVDResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.SVDResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_classmethod","is_ready"],"fullname":"numpy.linalg._linalg.SVDResult._make","name":"_make","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["_cls","iterable"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.SVDResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.SVDResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_make of SVDResult","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.SVDResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.SVDResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.SVDResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.SVDResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}}},"plugin_generated":true},"_replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5],"arg_names":["_self","U","S","Vh"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.SVDResult._replace","name":"_replace","original_first_arg":"_self","type":{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":["_self","U","S","Vh"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.SVDResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.SVDResult._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_replace of SVDResult","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.SVDResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.SVDResult._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.SVDResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.SVDResult._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_source":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.linalg._linalg.SVDResult._source","name":"_source","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.SVDResult.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":"numpy.linalg._linalg.SVDResult"},"values":[],"variance":0},"slots":null,"tuple_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_vars":[],"typeddict_type":null}},"SlogdetResult":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.linalg._linalg.SlogdetResult","name":"SlogdetResult","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_named_tuple"],"fullname":"numpy.linalg._linalg.SlogdetResult","has_param_spec_type":false,"metaclass_type":null,"metadata":{"namedtuple":{"fields":["sign","logabsdet"]}},"module_name":"numpy.linalg._linalg","mro":["numpy.linalg._linalg.SlogdetResult","builtins.tuple","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","_NT":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.SlogdetResult._NT","name":"_NT","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},"__annotations__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.linalg._linalg.SlogdetResult.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.linalg._linalg.SlogdetResult.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__new__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["_cls","sign","logabsdet"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static"],"fullname":"numpy.linalg._linalg.SlogdetResult.__new__","name":"__new__","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["_cls","sign","logabsdet"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.SlogdetResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.SlogdetResult.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of SlogdetResult","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.SlogdetResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.SlogdetResult.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.SlogdetResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.SlogdetResult.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_asdict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["_self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.SlogdetResult._asdict","name":"_asdict","original_first_arg":"_self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["_self"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.SlogdetResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.SlogdetResult._asdict","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_asdict of SlogdetResult","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.SlogdetResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.SlogdetResult._asdict","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_field_defaults":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.linalg._linalg.SlogdetResult._field_defaults","name":"_field_defaults","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_field_types":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.linalg._linalg.SlogdetResult._field_types","name":"_field_types","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_fields":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.linalg._linalg.SlogdetResult._fields","name":"_fields","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_make":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["_cls","iterable"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated"],"fullname":"numpy.linalg._linalg.SlogdetResult._make","name":"_make","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["_cls","iterable"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.SlogdetResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.SlogdetResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_make of SlogdetResult","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.SlogdetResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.SlogdetResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.SlogdetResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.SlogdetResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_classmethod","is_ready"],"fullname":"numpy.linalg._linalg.SlogdetResult._make","name":"_make","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["_cls","iterable"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.SlogdetResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.SlogdetResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_make of SlogdetResult","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.SlogdetResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.SlogdetResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.SlogdetResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.SlogdetResult._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}}},"plugin_generated":true},"_replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5],"arg_names":["_self","sign","logabsdet"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.SlogdetResult._replace","name":"_replace","original_first_arg":"_self","type":{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":["_self","sign","logabsdet"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.SlogdetResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.SlogdetResult._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_replace of SlogdetResult","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.SlogdetResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.SlogdetResult._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.SlogdetResult._NT","id":-1,"name":"_NT","namespace":"numpy.linalg._linalg.SlogdetResult._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_source":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.linalg._linalg.SlogdetResult._source","name":"_source","setter_type":null,"type":"builtins.str"}},"logabsdet":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"numpy.linalg._linalg.SlogdetResult.logabsdet","name":"logabsdet","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"logabsdet-redefinition":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.SlogdetResult.logabsdet","kind":"Mdef"},"sign":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"numpy.linalg._linalg.SlogdetResult.sign","name":"sign","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"sign-redefinition":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.SlogdetResult.sign","kind":"Mdef"}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg.SlogdetResult.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"partial_fallback":"numpy.linalg._linalg.SlogdetResult"},"values":[],"variance":0},"slots":null,"tuple_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_vars":[],"typeddict_type":null}},"SupportsIndex":{".class":"SymbolTableNode","cross_ref":"typing.SupportsIndex","kind":"Gdef","module_hidden":true,"module_public":false},"SupportsInt":{".class":"SymbolTableNode","cross_ref":"typing.SupportsInt","kind":"Gdef","module_hidden":true,"module_public":false},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.linalg._linalg.TypeAlias","source_any":null,"type_of_any":3}}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeBool_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeBool_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeComplex_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeComplex_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeFloat_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeFloat_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeInt_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeInt_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeObject_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeObject_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeTD64_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeTD64_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeUInt_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeUInt_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ModeKind":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.linalg._linalg._ModeKind","name":"_ModeKind","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.linalg._linalg.TypeAlias","source_any":null,"type_of_any":3}}},"_NoValueType":{".class":"SymbolTableNode","cross_ref":"numpy._globals._NoValueType","kind":"Gdef","module_hidden":true,"module_public":false},"_NumberT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg._NumberT","name":"_NumberT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},"values":[],"variance":0}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.linalg._linalg.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.linalg._linalg.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.linalg._linalg.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.linalg._linalg.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.linalg._linalg.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.linalg._linalg.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.linalg._linalg.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"cholesky":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.cholesky","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5],"arg_names":[null,"upper"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.cholesky","name":"cholesky","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,5],"arg_names":[null,"upper"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cholesky","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.cholesky","name":"cholesky","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5],"arg_names":[null,"upper"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cholesky","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5],"arg_names":[null,"upper"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.cholesky","name":"cholesky","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,5],"arg_names":[null,"upper"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cholesky","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.cholesky","name":"cholesky","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5],"arg_names":[null,"upper"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cholesky","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5],"arg_names":[null,"upper"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.cholesky","name":"cholesky","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,5],"arg_names":[null,"upper"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cholesky","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.cholesky","name":"cholesky","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5],"arg_names":[null,"upper"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cholesky","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,5],"arg_names":[null,"upper"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cholesky","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,5],"arg_names":[null,"upper"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cholesky","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,5],"arg_names":[null,"upper"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cholesky","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"complex128":{".class":"SymbolTableNode","cross_ref":"numpy.complex128","kind":"Gdef","module_hidden":true,"module_public":false},"complexfloating":{".class":"SymbolTableNode","cross_ref":"numpy.complexfloating","kind":"Gdef","module_hidden":true,"module_public":false},"cond":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["x","p"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.cond","name":"cond","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["x","p"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.float",{".class":"LiteralType","fallback":"builtins.str","value":"fro"},{".class":"LiteralType","fallback":"builtins.str","value":"nuc"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cond","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"cross":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.cross","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5],"arg_names":[null,null,"axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.cross","name":"cross","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":[null,null,"axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cross","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.cross","name":"cross","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":[null,null,"axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cross","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5],"arg_names":[null,null,"axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.cross","name":"cross","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":[null,null,"axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cross","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.cross","name":"cross","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":[null,null,"axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cross","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5],"arg_names":[null,null,"axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.cross","name":"cross","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":[null,null,"axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cross","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.cross","name":"cross","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":[null,null,"axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cross","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5],"arg_names":[null,null,"axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.cross","name":"cross","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":[null,null,"axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cross","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.cross","name":"cross","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":[null,null,"axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cross","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":[null,null,"axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cross","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":[null,null,"axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cross","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":[null,null,"axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cross","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":[null,null,"axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cross","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"det":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.det","name":"det","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"det","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"diagonal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5],"arg_names":[null,"offset"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.diagonal","name":"diagonal","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,5],"arg_names":[null,"offset"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"diagonal","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"eig":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.eig","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.eig","name":"eig","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eig","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.EigResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.eig","name":"eig","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eig","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.EigResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.eig","name":"eig","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eig","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.EigResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.eig","name":"eig","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eig","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.EigResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.eig","name":"eig","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eig","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.EigResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.eig","name":"eig","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eig","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.EigResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eig","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.EigResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eig","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.EigResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eig","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.EigResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"eigh":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.eigh","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","UPLO"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.eigh","name":"eigh","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","UPLO"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"L"},{".class":"LiteralType","fallback":"builtins.str","value":"U"},{".class":"LiteralType","fallback":"builtins.str","value":"l"},{".class":"LiteralType","fallback":"builtins.str","value":"u"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eigh","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.EighResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.eigh","name":"eigh","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","UPLO"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"L"},{".class":"LiteralType","fallback":"builtins.str","value":"U"},{".class":"LiteralType","fallback":"builtins.str","value":"l"},{".class":"LiteralType","fallback":"builtins.str","value":"u"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eigh","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.EighResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","UPLO"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.eigh","name":"eigh","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","UPLO"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"L"},{".class":"LiteralType","fallback":"builtins.str","value":"U"},{".class":"LiteralType","fallback":"builtins.str","value":"l"},{".class":"LiteralType","fallback":"builtins.str","value":"u"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eigh","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.EighResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.eigh","name":"eigh","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","UPLO"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"L"},{".class":"LiteralType","fallback":"builtins.str","value":"U"},{".class":"LiteralType","fallback":"builtins.str","value":"l"},{".class":"LiteralType","fallback":"builtins.str","value":"u"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eigh","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.EighResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","UPLO"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.eigh","name":"eigh","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","UPLO"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"L"},{".class":"LiteralType","fallback":"builtins.str","value":"U"},{".class":"LiteralType","fallback":"builtins.str","value":"l"},{".class":"LiteralType","fallback":"builtins.str","value":"u"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eigh","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.EighResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.eigh","name":"eigh","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","UPLO"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"L"},{".class":"LiteralType","fallback":"builtins.str","value":"U"},{".class":"LiteralType","fallback":"builtins.str","value":"l"},{".class":"LiteralType","fallback":"builtins.str","value":"u"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eigh","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.EighResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","UPLO"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"L"},{".class":"LiteralType","fallback":"builtins.str","value":"U"},{".class":"LiteralType","fallback":"builtins.str","value":"l"},{".class":"LiteralType","fallback":"builtins.str","value":"u"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eigh","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.EighResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","UPLO"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"L"},{".class":"LiteralType","fallback":"builtins.str","value":"U"},{".class":"LiteralType","fallback":"builtins.str","value":"l"},{".class":"LiteralType","fallback":"builtins.str","value":"u"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eigh","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.EighResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","UPLO"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"L"},{".class":"LiteralType","fallback":"builtins.str","value":"U"},{".class":"LiteralType","fallback":"builtins.str","value":"l"},{".class":"LiteralType","fallback":"builtins.str","value":"u"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eigh","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.EighResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"eigvals":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.eigvals","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.eigvals","name":"eigvals","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eigvals","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.eigvals","name":"eigvals","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eigvals","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.eigvals","name":"eigvals","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eigvals","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.eigvals","name":"eigvals","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eigvals","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.eigvals","name":"eigvals","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eigvals","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.eigvals","name":"eigvals","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eigvals","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eigvals","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eigvals","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eigvals","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"eigvalsh":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.eigvalsh","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","UPLO"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.eigvalsh","name":"eigvalsh","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","UPLO"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"L"},{".class":"LiteralType","fallback":"builtins.str","value":"U"},{".class":"LiteralType","fallback":"builtins.str","value":"l"},{".class":"LiteralType","fallback":"builtins.str","value":"u"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eigvalsh","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.eigvalsh","name":"eigvalsh","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","UPLO"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"L"},{".class":"LiteralType","fallback":"builtins.str","value":"U"},{".class":"LiteralType","fallback":"builtins.str","value":"l"},{".class":"LiteralType","fallback":"builtins.str","value":"u"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eigvalsh","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","UPLO"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.eigvalsh","name":"eigvalsh","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","UPLO"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"L"},{".class":"LiteralType","fallback":"builtins.str","value":"U"},{".class":"LiteralType","fallback":"builtins.str","value":"l"},{".class":"LiteralType","fallback":"builtins.str","value":"u"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eigvalsh","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.eigvalsh","name":"eigvalsh","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","UPLO"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"L"},{".class":"LiteralType","fallback":"builtins.str","value":"U"},{".class":"LiteralType","fallback":"builtins.str","value":"l"},{".class":"LiteralType","fallback":"builtins.str","value":"u"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eigvalsh","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","UPLO"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"L"},{".class":"LiteralType","fallback":"builtins.str","value":"U"},{".class":"LiteralType","fallback":"builtins.str","value":"l"},{".class":"LiteralType","fallback":"builtins.str","value":"u"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eigvalsh","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","UPLO"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"L"},{".class":"LiteralType","fallback":"builtins.str","value":"U"},{".class":"LiteralType","fallback":"builtins.str","value":"l"},{".class":"LiteralType","fallback":"builtins.str","value":"u"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eigvalsh","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"float64":{".class":"SymbolTableNode","cross_ref":"numpy.float64","kind":"Gdef","module_hidden":true,"module_public":false},"floating":{".class":"SymbolTableNode","cross_ref":"numpy.floating","kind":"Gdef","module_hidden":true,"module_public":false},"fortran_int":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy.linalg._linalg.fortran_int","line":88,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intc"}}},"int32":{".class":"SymbolTableNode","cross_ref":"numpy.int32","kind":"Gdef","module_hidden":true,"module_public":false},"inv":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.inv","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.inv","name":"inv","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"inv","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.inv","name":"inv","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"inv","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.inv","name":"inv","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"inv","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.inv","name":"inv","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"inv","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.inv","name":"inv","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"inv","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.inv","name":"inv","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"inv","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"inv","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"inv","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"inv","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"lstsq":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.lstsq","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","b","rcond"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.lstsq","name":"lstsq","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","rcond"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstsq","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.lstsq","name":"lstsq","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","rcond"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstsq","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","b","rcond"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.lstsq","name":"lstsq","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","rcond"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstsq","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.lstsq","name":"lstsq","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","rcond"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstsq","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","b","rcond"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.lstsq","name":"lstsq","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","rcond"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstsq","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.lstsq","name":"lstsq","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","rcond"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstsq","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","rcond"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstsq","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","rcond"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstsq","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","rcond"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lstsq","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"matmul":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.matmul","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.matmul","name":"matmul","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"matmul","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg._NumberT","id":-1,"name":"_NumberT","namespace":"numpy.linalg._linalg.matmul#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.matmul","name":"matmul","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"matmul","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg._NumberT","id":-1,"name":"_NumberT","namespace":"numpy.linalg._linalg.matmul#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.matmul","name":"matmul","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"matmul","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.matmul","name":"matmul","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"matmul","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.matmul","name":"matmul","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"matmul","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.matmul","name":"matmul","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"matmul","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.matmul","name":"matmul","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"matmul","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.matmul","name":"matmul","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"matmul","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.matmul","name":"matmul","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"matmul","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.matmul","name":"matmul","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"matmul","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"matmul","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg._NumberT","id":-1,"name":"_NumberT","namespace":"numpy.linalg._linalg.matmul#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"matmul","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"matmul","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"matmul","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"matmul","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"matrix_norm":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.matrix_norm","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5],"arg_names":[null,"ord","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.matrix_norm","name":"matrix_norm","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":[null,"ord","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.float",{".class":"LiteralType","fallback":"builtins.str","value":"fro"},{".class":"LiteralType","fallback":"builtins.str","value":"nuc"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"matrix_norm","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.matrix_norm","name":"matrix_norm","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":[null,"ord","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.float",{".class":"LiteralType","fallback":"builtins.str","value":"fro"},{".class":"LiteralType","fallback":"builtins.str","value":"nuc"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"matrix_norm","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5],"arg_names":[null,"ord","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.matrix_norm","name":"matrix_norm","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":[null,"ord","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.float",{".class":"LiteralType","fallback":"builtins.str","value":"fro"},{".class":"LiteralType","fallback":"builtins.str","value":"nuc"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"matrix_norm","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.matrix_norm","name":"matrix_norm","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":[null,"ord","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.float",{".class":"LiteralType","fallback":"builtins.str","value":"fro"},{".class":"LiteralType","fallback":"builtins.str","value":"nuc"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"matrix_norm","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":[null,"ord","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.float",{".class":"LiteralType","fallback":"builtins.str","value":"fro"},{".class":"LiteralType","fallback":"builtins.str","value":"nuc"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"matrix_norm","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":[null,"ord","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.float",{".class":"LiteralType","fallback":"builtins.str","value":"fro"},{".class":"LiteralType","fallback":"builtins.str","value":"nuc"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"matrix_norm","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"matrix_power":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","n"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.matrix_power","name":"matrix_power","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","n"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"matrix_power","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"matrix_rank":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,5],"arg_names":["A","tol","hermitian","rtol"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.matrix_rank","name":"matrix_rank","original_first_arg":"A","type":{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["A","tol","hermitian","rtol"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"matrix_rank","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"matrix_transpose":{".class":"SymbolTableNode","cross_ref":"numpy._core.fromnumeric.matrix_transpose","kind":"Gdef"},"multi_dot":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5],"arg_names":["arrays","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.multi_dot","name":"multi_dot","original_first_arg":"arrays","type":{".class":"CallableType","arg_kinds":[0,5],"arg_names":["arrays","out"],"arg_types":[{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"multi_dot","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"norm":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.norm","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["x","ord","axis","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.norm","name":"norm","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["x","ord","axis","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.float",{".class":"LiteralType","fallback":"builtins.str","value":"fro"},{".class":"LiteralType","fallback":"builtins.str","value":"nuc"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"norm","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.norm","name":"norm","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["x","ord","axis","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.float",{".class":"LiteralType","fallback":"builtins.str","value":"fro"},{".class":"LiteralType","fallback":"builtins.str","value":"nuc"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"norm","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["x","ord","axis","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.norm","name":"norm","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["x","ord","axis","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.float",{".class":"LiteralType","fallback":"builtins.str","value":"fro"},{".class":"LiteralType","fallback":"builtins.str","value":"nuc"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsInt","typing.SupportsIndex",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"norm","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.norm","name":"norm","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["x","ord","axis","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.float",{".class":"LiteralType","fallback":"builtins.str","value":"fro"},{".class":"LiteralType","fallback":"builtins.str","value":"nuc"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsInt","typing.SupportsIndex",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"norm","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["x","ord","axis","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.float",{".class":"LiteralType","fallback":"builtins.str","value":"fro"},{".class":"LiteralType","fallback":"builtins.str","value":"nuc"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"norm","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["x","ord","axis","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.float",{".class":"LiteralType","fallback":"builtins.str","value":"fro"},{".class":"LiteralType","fallback":"builtins.str","value":"nuc"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["typing.SupportsInt","typing.SupportsIndex",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"norm","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"object_":{".class":"SymbolTableNode","cross_ref":"numpy.object_","kind":"Gdef","module_hidden":true,"module_public":false},"outer":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.outer","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.outer","name":"outer","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.outer","name":"outer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.outer","name":"outer","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.outer","name":"outer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.outer","name":"outer","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg._NumberT","id":-1,"name":"_NumberT","namespace":"numpy.linalg._linalg.outer#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.outer","name":"outer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg._NumberT","id":-1,"name":"_NumberT","namespace":"numpy.linalg._linalg.outer#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.outer","name":"outer","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.outer","name":"outer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.outer","name":"outer","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.outer","name":"outer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.outer","name":"outer","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.outer","name":"outer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.outer","name":"outer","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.outer","name":"outer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.outer","name":"outer","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.outer","name":"outer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.outer","name":"outer","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.outer","name":"outer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.outer","name":"outer","original_first_arg":"x1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.outer","name":"outer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.linalg._linalg._NumberT","id":-1,"name":"_NumberT","namespace":"numpy.linalg._linalg.outer#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"outer","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false},"pinv":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.pinv","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,5],"arg_names":["a","rcond","hermitian","rtol"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.pinv","name":"pinv","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["a","rcond","hermitian","rtol"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pinv","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.pinv","name":"pinv","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["a","rcond","hermitian","rtol"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pinv","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,5],"arg_names":["a","rcond","hermitian","rtol"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.pinv","name":"pinv","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["a","rcond","hermitian","rtol"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pinv","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.pinv","name":"pinv","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["a","rcond","hermitian","rtol"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pinv","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,5],"arg_names":["a","rcond","hermitian","rtol"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.pinv","name":"pinv","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["a","rcond","hermitian","rtol"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pinv","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.pinv","name":"pinv","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["a","rcond","hermitian","rtol"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pinv","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["a","rcond","hermitian","rtol"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pinv","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["a","rcond","hermitian","rtol"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pinv","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,5],"arg_names":["a","rcond","hermitian","rtol"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pinv","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"qr":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.qr","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.qr","name":"qr","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.linalg._linalg.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"qr","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.QRResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.qr","name":"qr","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.linalg._linalg.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"qr","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.QRResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.qr","name":"qr","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.linalg._linalg.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"qr","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.QRResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.qr","name":"qr","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.linalg._linalg.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"qr","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.QRResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.qr","name":"qr","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.linalg._linalg.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"qr","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.QRResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.qr","name":"qr","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.linalg._linalg.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"qr","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.QRResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.linalg._linalg.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"qr","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.QRResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.linalg._linalg.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"qr","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.QRResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.linalg._linalg.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"qr","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.QRResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"signedinteger":{".class":"SymbolTableNode","cross_ref":"numpy.signedinteger","kind":"Gdef","module_hidden":true,"module_public":false},"slogdet":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.slogdet","name":"slogdet","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"slogdet","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.SlogdetResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"solve":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.solve","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","b"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.solve","name":"solve","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","b"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"solve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.solve","name":"solve","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","b"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"solve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","b"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.solve","name":"solve","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","b"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"solve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.solve","name":"solve","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","b"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"solve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","b"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.solve","name":"solve","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","b"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"solve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.solve","name":"solve","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","b"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"solve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","b"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"solve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","b"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"solve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","b"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"solve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"svd":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.svd","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["a","full_matrices","compute_uv","hermitian"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.svd","name":"svd","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","full_matrices","compute_uv","hermitian"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"svd","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.SVDResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.svd","name":"svd","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","full_matrices","compute_uv","hermitian"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"svd","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.SVDResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["a","full_matrices","compute_uv","hermitian"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.svd","name":"svd","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","full_matrices","compute_uv","hermitian"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"svd","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.SVDResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.svd","name":"svd","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","full_matrices","compute_uv","hermitian"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"svd","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.SVDResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["a","full_matrices","compute_uv","hermitian"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.svd","name":"svd","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","full_matrices","compute_uv","hermitian"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"svd","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.SVDResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.svd","name":"svd","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","full_matrices","compute_uv","hermitian"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"svd","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.SVDResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["a","full_matrices","compute_uv","hermitian"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.svd","name":"svd","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","full_matrices","compute_uv","hermitian"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"svd","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.svd","name":"svd","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","full_matrices","compute_uv","hermitian"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"svd","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["a","full_matrices","compute_uv","hermitian"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.svd","name":"svd","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","full_matrices","compute_uv","hermitian"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"svd","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.svd","name":"svd","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","full_matrices","compute_uv","hermitian"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"svd","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","full_matrices","compute_uv","hermitian"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"svd","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.SVDResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","full_matrices","compute_uv","hermitian"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"svd","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.SVDResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","full_matrices","compute_uv","hermitian"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"svd","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.linalg._linalg.SVDResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","full_matrices","compute_uv","hermitian"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"svd","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","full_matrices","compute_uv","hermitian"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"LiteralType","fallback":"builtins.bool","value":false},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"svd","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"svdvals":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.svdvals","name":"svdvals","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"svdvals","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"tensordot":{".class":"SymbolTableNode","cross_ref":"numpy._core.numeric.tensordot","kind":"Gdef"},"tensorinv":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.tensorinv","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","ind"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.tensorinv","name":"tensorinv","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","ind"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensorinv","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.tensorinv","name":"tensorinv","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","ind"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensorinv","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","ind"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.tensorinv","name":"tensorinv","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","ind"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensorinv","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.tensorinv","name":"tensorinv","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","ind"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensorinv","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","ind"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.tensorinv","name":"tensorinv","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","ind"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensorinv","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.tensorinv","name":"tensorinv","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","ind"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensorinv","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","ind"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensorinv","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","ind"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensorinv","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","ind"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensorinv","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"tensorsolve":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.tensorsolve","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.tensorsolve","name":"tensorsolve","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensorsolve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.tensorsolve","name":"tensorsolve","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensorsolve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.tensorsolve","name":"tensorsolve","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensorsolve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.tensorsolve","name":"tensorsolve","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensorsolve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.tensorsolve","name":"tensorsolve","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensorsolve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.tensorsolve","name":"tensorsolve","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensorsolve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensorsolve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensorsolve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","axes"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tensorsolve","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"timedelta64":{".class":"SymbolTableNode","cross_ref":"numpy.timedelta64","kind":"Gdef","module_hidden":true,"module_public":false},"trace":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5],"arg_names":[null,"offset","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.trace","name":"trace","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":[null,"offset","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trace","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"unsignedinteger":{".class":"SymbolTableNode","cross_ref":"numpy.unsignedinteger","kind":"Gdef","module_hidden":true,"module_public":false},"vecdot":{".class":"SymbolTableNode","cross_ref":"numpy.vecdot","kind":"Gdef"},"vector_norm":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.linalg._linalg.vector_norm","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5],"arg_names":[null,"axis","ord","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.vector_norm","name":"vector_norm","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":[null,"axis","ord","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vector_norm","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.vector_norm","name":"vector_norm","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":[null,"axis","ord","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vector_norm","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5],"arg_names":[null,"axis","ord","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.linalg._linalg.vector_norm","name":"vector_norm","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":[null,"axis","ord","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsInt","typing.SupportsIndex",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vector_norm","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.linalg._linalg.vector_norm","name":"vector_norm","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":[null,"axis","ord","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsInt","typing.SupportsIndex",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vector_norm","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":[null,"axis","ord","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vector_norm","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":[null,"axis","ord","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsInt","typing.SupportsIndex",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vector_norm","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/linalg/_linalg.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/linalg/_linalg.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/linalg/_linalg.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..0222e65d0814f40400991f4341d634b4f46b06b4 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/linalg/_linalg.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[29,30,1,31,32,45,2,14,1,1,1,1],"dep_prios":[5,5,5,5,5,5,5,5,5,30,30,30],"dependencies":["numpy._core.fromnumeric","numpy._core.numeric","collections.abc","numpy._globals","numpy._typing","numpy.linalg","typing","numpy","builtins","_frozen_importlib","abc","numpy._typing._nbit_base"],"hash":"d99071536001901b2deb5db53f06e34c9d68f1d0","id":"numpy.linalg._linalg","ignore_all":true,"interface_hash":"914c68e3334dc7ff2ea94e12cd60cd3bb8dc1bbf","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/linalg/_linalg.pyi","plugin_data":null,"size":11548,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/linalg/_umath_linalg.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/linalg/_umath_linalg.data.json new file mode 100644 index 0000000000000000000000000000000000000000..10d204d6aec922f1de369744dcfef96bad5c58d7 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/linalg/_umath_linalg.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.linalg._umath_linalg","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Final":{".class":"SymbolTableNode","cross_ref":"typing.Final","kind":"Gdef","module_hidden":true,"module_public":false},"L":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"_GUFunc_Nin2_Nout1":{".class":"SymbolTableNode","cross_ref":"numpy._typing._ufunc._GUFunc_Nin2_Nout1","kind":"Gdef","module_hidden":true,"module_public":false},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.linalg._umath_linalg.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.linalg._umath_linalg.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.linalg._umath_linalg.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.linalg._umath_linalg.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.linalg._umath_linalg.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.linalg._umath_linalg.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"__version__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.linalg._umath_linalg.__version__","name":"__version__","setter_type":null,"type":"builtins.str"}},"_ilp64":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.linalg._umath_linalg._ilp64","name":"_ilp64","setter_type":null,"type":"builtins.bool"}},"cholesky_lo":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.linalg._umath_linalg.cholesky_lo","name":"cholesky_lo","setter_type":null,"type":"numpy.ufunc"}},"cholesky_up":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.linalg._umath_linalg.cholesky_up","name":"cholesky_up","setter_type":null,"type":"numpy.ufunc"}},"det":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.linalg._umath_linalg.det","name":"det","setter_type":null,"type":"numpy.ufunc"}},"eig":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.linalg._umath_linalg.eig","name":"eig","setter_type":null,"type":"numpy.ufunc"}},"eigh_lo":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.linalg._umath_linalg.eigh_lo","name":"eigh_lo","setter_type":null,"type":"numpy.ufunc"}},"eigh_up":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.linalg._umath_linalg.eigh_up","name":"eigh_up","setter_type":null,"type":"numpy.ufunc"}},"eigvals":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.linalg._umath_linalg.eigvals","name":"eigvals","setter_type":null,"type":"numpy.ufunc"}},"eigvalsh_lo":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.linalg._umath_linalg.eigvalsh_lo","name":"eigvalsh_lo","setter_type":null,"type":"numpy.ufunc"}},"eigvalsh_up":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.linalg._umath_linalg.eigvalsh_up","name":"eigvalsh_up","setter_type":null,"type":"numpy.ufunc"}},"inv":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.linalg._umath_linalg.inv","name":"inv","setter_type":null,"type":"numpy.ufunc"}},"lstsq":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.linalg._umath_linalg.lstsq","name":"lstsq","setter_type":null,"type":"numpy.ufunc"}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"qr_complete":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.linalg._umath_linalg.qr_complete","name":"qr_complete","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"qr_complete"},{".class":"LiteralType","fallback":"builtins.int","value":2},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.str","value":"(m,n),(n)->(m,m)"}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._GUFunc_Nin2_Nout1"}}},"qr_r_raw":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.linalg._umath_linalg.qr_r_raw","name":"qr_r_raw","setter_type":null,"type":"numpy.ufunc"}},"qr_reduced":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.linalg._umath_linalg.qr_reduced","name":"qr_reduced","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"qr_reduced"},{".class":"LiteralType","fallback":"builtins.int","value":2},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.str","value":"(m,n),(k)->(m,k)"}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._GUFunc_Nin2_Nout1"}}},"slogdet":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.linalg._umath_linalg.slogdet","name":"slogdet","setter_type":null,"type":"numpy.ufunc"}},"solve":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.linalg._umath_linalg.solve","name":"solve","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"solve"},{".class":"LiteralType","fallback":"builtins.int","value":4},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.str","value":"(m,m),(m,n)->(m,n)"}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._GUFunc_Nin2_Nout1"}}},"solve1":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.linalg._umath_linalg.solve1","name":"solve1","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"solve1"},{".class":"LiteralType","fallback":"builtins.int","value":4},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.str","value":"(m,m),(m)->(m)"}],"extra_attrs":null,"type_ref":"numpy._typing._ufunc._GUFunc_Nin2_Nout1"}}},"svd":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.linalg._umath_linalg.svd","name":"svd","setter_type":null,"type":"numpy.ufunc"}},"svd_f":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.linalg._umath_linalg.svd_f","name":"svd_f","setter_type":null,"type":"numpy.ufunc"}},"svd_s":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.linalg._umath_linalg.svd_s","name":"svd_s","setter_type":null,"type":"numpy.ufunc"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/linalg/_umath_linalg.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/linalg/_umath_linalg.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/linalg/_umath_linalg.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..f7a3b1b7949ccd67462e7c148a267a6316d09616 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/linalg/_umath_linalg.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[5,1,4,1,1,1,1],"dep_prios":[5,5,10,5,30,30,30],"dependencies":["numpy._typing._ufunc","typing","numpy","builtins","_frozen_importlib","abc","numpy._typing"],"hash":"2f6c1e37854f82fc3103cc6bbc38dc81e1b5c425","id":"numpy.linalg._umath_linalg","ignore_all":true,"interface_hash":"63464f5df39ded8d5bc17c99a8cc7301386857a1","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/linalg/_umath_linalg.pyi","plugin_data":null,"size":1409,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/linalg/linalg.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/linalg/linalg.data.json new file mode 100644 index 0000000000000000000000000000000000000000..2312fca5408af24dec2882992e585f05694e9cc8 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/linalg/linalg.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.linalg.linalg","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","LinAlgError":{".class":"SymbolTableNode","cross_ref":"numpy.linalg.LinAlgError","kind":"Gdef"},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.linalg.linalg.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.linalg.linalg.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.linalg.linalg.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.linalg.linalg.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.linalg.linalg.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.linalg.linalg.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.linalg.linalg.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"cholesky":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.cholesky","kind":"Gdef"},"cond":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.cond","kind":"Gdef"},"cross":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.cross","kind":"Gdef"},"det":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.det","kind":"Gdef"},"diagonal":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.diagonal","kind":"Gdef"},"eig":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.eig","kind":"Gdef"},"eigh":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.eigh","kind":"Gdef"},"eigvals":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.eigvals","kind":"Gdef"},"eigvalsh":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.eigvalsh","kind":"Gdef"},"inv":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.inv","kind":"Gdef"},"lstsq":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.lstsq","kind":"Gdef"},"matmul":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.matmul","kind":"Gdef"},"matrix_norm":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.matrix_norm","kind":"Gdef"},"matrix_power":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.matrix_power","kind":"Gdef"},"matrix_rank":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.matrix_rank","kind":"Gdef"},"matrix_transpose":{".class":"SymbolTableNode","cross_ref":"numpy._core.fromnumeric.matrix_transpose","kind":"Gdef"},"multi_dot":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.multi_dot","kind":"Gdef"},"norm":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.norm","kind":"Gdef"},"outer":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.outer","kind":"Gdef"},"pinv":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.pinv","kind":"Gdef"},"qr":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.qr","kind":"Gdef"},"slogdet":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.slogdet","kind":"Gdef"},"solve":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.solve","kind":"Gdef"},"svd":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.svd","kind":"Gdef"},"svdvals":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.svdvals","kind":"Gdef"},"tensordot":{".class":"SymbolTableNode","cross_ref":"numpy._core.numeric.tensordot","kind":"Gdef"},"tensorinv":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.tensorinv","kind":"Gdef"},"tensorsolve":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.tensorsolve","kind":"Gdef"},"trace":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.trace","kind":"Gdef"},"vecdot":{".class":"SymbolTableNode","cross_ref":"numpy.vecdot","kind":"Gdef"},"vector_norm":{".class":"SymbolTableNode","cross_ref":"numpy.linalg._linalg.vector_norm","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/linalg/linalg.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/linalg/linalg.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/linalg/linalg.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..7c6f68c7d5516c206fca97141c07cfb955d54125 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/linalg/linalg.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,1,1,1,1],"dep_prios":[5,5,30,30,30],"dependencies":["numpy.linalg._linalg","builtins","_frozen_importlib","abc","typing"],"hash":"38c403037e708d8b5f37a71aa0fd4f813cb1b1f5","id":"numpy.linalg.linalg","ignore_all":true,"interface_hash":"727493852f419fff5d6a53561fde7c24847e6044","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/linalg/linalg.pyi","plugin_data":null,"size":932,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/ma/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/ma/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..5bbf6871d67d44560b6422ef0b56e3b8fc58b0c7 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/ma/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.ma","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","MAError":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.MAError","kind":"Gdef"},"MaskError":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.MaskError","kind":"Gdef"},"MaskType":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.MaskType","kind":"Gdef"},"MaskedArray":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.MaskedArray","kind":"Gdef"},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.ma.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"abs":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.abs","kind":"Gdef"},"absolute":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.absolute","kind":"Gdef"},"add":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.add","kind":"Gdef"},"all":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.all","kind":"Gdef"},"allclose":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.allclose","kind":"Gdef"},"allequal":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.allequal","kind":"Gdef"},"alltrue":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.alltrue","kind":"Gdef"},"amax":{".class":"SymbolTableNode","cross_ref":"numpy._core.fromnumeric.amax","kind":"Gdef"},"amin":{".class":"SymbolTableNode","cross_ref":"numpy._core.fromnumeric.amin","kind":"Gdef"},"angle":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.angle","kind":"Gdef"},"anom":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.anom","kind":"Gdef"},"anomalies":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.anomalies","kind":"Gdef"},"any":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.any","kind":"Gdef"},"append":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.append","kind":"Gdef"},"apply_along_axis":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.apply_along_axis","kind":"Gdef"},"apply_over_axes":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.apply_over_axes","kind":"Gdef"},"arange":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.arange","kind":"Gdef"},"arccos":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.arccos","kind":"Gdef"},"arccosh":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.arccosh","kind":"Gdef"},"arcsin":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.arcsin","kind":"Gdef"},"arcsinh":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.arcsinh","kind":"Gdef"},"arctan":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.arctan","kind":"Gdef"},"arctan2":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.arctan2","kind":"Gdef"},"arctanh":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.arctanh","kind":"Gdef"},"argmax":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.argmax","kind":"Gdef"},"argmin":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.argmin","kind":"Gdef"},"argsort":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.argsort","kind":"Gdef"},"around":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.around","kind":"Gdef"},"array":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.array","kind":"Gdef"},"asanyarray":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.asanyarray","kind":"Gdef"},"asarray":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.asarray","kind":"Gdef"},"atleast_1d":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.atleast_1d","kind":"Gdef"},"atleast_2d":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.atleast_2d","kind":"Gdef"},"atleast_3d":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.atleast_3d","kind":"Gdef"},"average":{".class":"SymbolTableNode","cross_ref":"numpy.lib._function_base_impl.average","kind":"Gdef"},"bitwise_and":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.bitwise_and","kind":"Gdef"},"bitwise_or":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.bitwise_or","kind":"Gdef"},"bitwise_xor":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.bitwise_xor","kind":"Gdef"},"bool_":{".class":"SymbolTableNode","cross_ref":"numpy.bool_","kind":"Gdef"},"ceil":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.ceil","kind":"Gdef"},"choose":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.choose","kind":"Gdef"},"clip":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.clip","kind":"Gdef"},"clump_masked":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.clump_masked","kind":"Gdef"},"clump_unmasked":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.clump_unmasked","kind":"Gdef"},"column_stack":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.column_stack","kind":"Gdef"},"common_fill_value":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.common_fill_value","kind":"Gdef"},"compress":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.compress","kind":"Gdef"},"compress_cols":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.compress_cols","kind":"Gdef"},"compress_nd":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.compress_nd","kind":"Gdef"},"compress_rowcols":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.compress_rowcols","kind":"Gdef"},"compress_rows":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.compress_rows","kind":"Gdef"},"compressed":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.compressed","kind":"Gdef"},"concatenate":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.concatenate","kind":"Gdef"},"conjugate":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.conjugate","kind":"Gdef"},"convolve":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.convolve","kind":"Gdef"},"copy":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.copy","kind":"Gdef"},"core":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core","kind":"Gdef"},"corrcoef":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.corrcoef","kind":"Gdef"},"correlate":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.correlate","kind":"Gdef"},"cos":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.cos","kind":"Gdef"},"cosh":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.cosh","kind":"Gdef"},"count":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.count","kind":"Gdef"},"count_masked":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.count_masked","kind":"Gdef"},"cov":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.cov","kind":"Gdef"},"cumprod":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.cumprod","kind":"Gdef"},"cumsum":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.cumsum","kind":"Gdef"},"default_fill_value":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.default_fill_value","kind":"Gdef"},"diag":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.diag","kind":"Gdef"},"diagflat":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.diagflat","kind":"Gdef"},"diagonal":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.diagonal","kind":"Gdef"},"diff":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.diff","kind":"Gdef"},"divide":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.divide","kind":"Gdef"},"dot":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.dot","kind":"Gdef"},"dstack":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.dstack","kind":"Gdef"},"ediff1d":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.ediff1d","kind":"Gdef"},"empty":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.empty","kind":"Gdef"},"empty_like":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.empty_like","kind":"Gdef"},"equal":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.equal","kind":"Gdef"},"exp":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.exp","kind":"Gdef"},"expand_dims":{".class":"SymbolTableNode","cross_ref":"numpy.lib._shape_base_impl.expand_dims","kind":"Gdef"},"extras":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras","kind":"Gdef"},"fabs":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.fabs","kind":"Gdef"},"filled":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.filled","kind":"Gdef"},"fix_invalid":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.fix_invalid","kind":"Gdef"},"flatnotmasked_contiguous":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.flatnotmasked_contiguous","kind":"Gdef"},"flatnotmasked_edges":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.flatnotmasked_edges","kind":"Gdef"},"flatten_mask":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.flatten_mask","kind":"Gdef"},"flatten_structured_array":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.flatten_structured_array","kind":"Gdef"},"floor":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.floor","kind":"Gdef"},"floor_divide":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.floor_divide","kind":"Gdef"},"fmod":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.fmod","kind":"Gdef"},"frombuffer":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.frombuffer","kind":"Gdef"},"fromflex":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.fromflex","kind":"Gdef"},"fromfunction":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.fromfunction","kind":"Gdef"},"getdata":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.getdata","kind":"Gdef"},"getmask":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.getmask","kind":"Gdef"},"getmaskarray":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.getmaskarray","kind":"Gdef"},"greater":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.greater","kind":"Gdef"},"greater_equal":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.greater_equal","kind":"Gdef"},"harden_mask":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.harden_mask","kind":"Gdef"},"hsplit":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.hsplit","kind":"Gdef"},"hstack":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.hstack","kind":"Gdef"},"hypot":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.hypot","kind":"Gdef"},"identity":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.identity","kind":"Gdef"},"ids":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.ids","kind":"Gdef"},"in1d":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.in1d","kind":"Gdef"},"indices":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.indices","kind":"Gdef"},"inner":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.inner","kind":"Gdef"},"innerproduct":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.innerproduct","kind":"Gdef"},"intersect1d":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.intersect1d","kind":"Gdef"},"isMA":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.isMA","kind":"Gdef"},"isMaskedArray":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.isMaskedArray","kind":"Gdef"},"is_mask":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.is_mask","kind":"Gdef"},"is_masked":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.is_masked","kind":"Gdef"},"isarray":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.isarray","kind":"Gdef"},"isin":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.isin","kind":"Gdef"},"left_shift":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.left_shift","kind":"Gdef"},"less":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.less","kind":"Gdef"},"less_equal":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.less_equal","kind":"Gdef"},"log":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.log","kind":"Gdef"},"log10":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.log10","kind":"Gdef"},"log2":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.log2","kind":"Gdef"},"logical_and":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.logical_and","kind":"Gdef"},"logical_not":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.logical_not","kind":"Gdef"},"logical_or":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.logical_or","kind":"Gdef"},"logical_xor":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.logical_xor","kind":"Gdef"},"make_mask":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.make_mask","kind":"Gdef"},"make_mask_descr":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.make_mask_descr","kind":"Gdef"},"make_mask_none":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.make_mask_none","kind":"Gdef"},"mask_cols":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.mask_cols","kind":"Gdef"},"mask_or":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.mask_or","kind":"Gdef"},"mask_rowcols":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.mask_rowcols","kind":"Gdef"},"mask_rows":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.mask_rows","kind":"Gdef"},"masked":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.masked","kind":"Gdef"},"masked_all":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.masked_all","kind":"Gdef"},"masked_all_like":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.masked_all_like","kind":"Gdef"},"masked_array":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.masked_array","kind":"Gdef"},"masked_equal":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.masked_equal","kind":"Gdef"},"masked_greater":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.masked_greater","kind":"Gdef"},"masked_greater_equal":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.masked_greater_equal","kind":"Gdef"},"masked_inside":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.masked_inside","kind":"Gdef"},"masked_invalid":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.masked_invalid","kind":"Gdef"},"masked_less":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.masked_less","kind":"Gdef"},"masked_less_equal":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.masked_less_equal","kind":"Gdef"},"masked_not_equal":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.masked_not_equal","kind":"Gdef"},"masked_object":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.masked_object","kind":"Gdef"},"masked_outside":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.masked_outside","kind":"Gdef"},"masked_print_option":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.masked_print_option","kind":"Gdef"},"masked_singleton":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.masked_singleton","kind":"Gdef"},"masked_values":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.masked_values","kind":"Gdef"},"masked_where":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.masked_where","kind":"Gdef"},"max":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.max","kind":"Gdef"},"maximum":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.maximum","kind":"Gdef"},"maximum_fill_value":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.maximum_fill_value","kind":"Gdef"},"mean":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.mean","kind":"Gdef"},"median":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.median","kind":"Gdef"},"min":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.min","kind":"Gdef"},"minimum":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.minimum","kind":"Gdef"},"minimum_fill_value":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.minimum_fill_value","kind":"Gdef"},"mod":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.mod","kind":"Gdef"},"mr_":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.mr_","kind":"Gdef"},"multiply":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.multiply","kind":"Gdef"},"mvoid":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.mvoid","kind":"Gdef"},"ndenumerate":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.ndenumerate","kind":"Gdef"},"ndim":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.ndim","kind":"Gdef"},"negative":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.negative","kind":"Gdef"},"nomask":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.nomask","kind":"Gdef"},"nonzero":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.nonzero","kind":"Gdef"},"not_equal":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.not_equal","kind":"Gdef"},"notmasked_contiguous":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.notmasked_contiguous","kind":"Gdef"},"notmasked_edges":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.notmasked_edges","kind":"Gdef"},"ones":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.ones","kind":"Gdef"},"ones_like":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.ones_like","kind":"Gdef"},"outer":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.outer","kind":"Gdef"},"outerproduct":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.outerproduct","kind":"Gdef"},"polyfit":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.polyfit","kind":"Gdef"},"power":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.power","kind":"Gdef"},"prod":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.prod","kind":"Gdef"},"product":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.product","kind":"Gdef"},"ptp":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.ptp","kind":"Gdef"},"put":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.put","kind":"Gdef"},"putmask":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.putmask","kind":"Gdef"},"ravel":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.ravel","kind":"Gdef"},"remainder":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.remainder","kind":"Gdef"},"repeat":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.repeat","kind":"Gdef"},"reshape":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.reshape","kind":"Gdef"},"resize":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.resize","kind":"Gdef"},"right_shift":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.right_shift","kind":"Gdef"},"round":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.round","kind":"Gdef"},"round_":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.round_","kind":"Gdef"},"row_stack":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.row_stack","kind":"Gdef"},"set_fill_value":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.set_fill_value","kind":"Gdef"},"setdiff1d":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.setdiff1d","kind":"Gdef"},"setxor1d":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.setxor1d","kind":"Gdef"},"shape":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.shape","kind":"Gdef"},"sin":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.sin","kind":"Gdef"},"sinh":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.sinh","kind":"Gdef"},"size":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.size","kind":"Gdef"},"soften_mask":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.soften_mask","kind":"Gdef"},"sometrue":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.sometrue","kind":"Gdef"},"sort":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.sort","kind":"Gdef"},"sqrt":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.sqrt","kind":"Gdef"},"squeeze":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.squeeze","kind":"Gdef"},"stack":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.stack","kind":"Gdef"},"std":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.std","kind":"Gdef"},"subtract":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.subtract","kind":"Gdef"},"sum":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.sum","kind":"Gdef"},"swapaxes":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.swapaxes","kind":"Gdef"},"take":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.take","kind":"Gdef"},"tan":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.tan","kind":"Gdef"},"tanh":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.tanh","kind":"Gdef"},"trace":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.trace","kind":"Gdef"},"transpose":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.transpose","kind":"Gdef"},"true_divide":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.true_divide","kind":"Gdef"},"union1d":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.union1d","kind":"Gdef"},"unique":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.unique","kind":"Gdef"},"vander":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.vander","kind":"Gdef"},"var":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.var","kind":"Gdef"},"vstack":{".class":"SymbolTableNode","cross_ref":"numpy.ma.extras.vstack","kind":"Gdef"},"where":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.where","kind":"Gdef"},"zeros":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.zeros","kind":"Gdef"},"zeros_like":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.zeros_like","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/ma/__init__.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/ma/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/ma/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..0053dba55bed959fabc9b04d2efc6222fd0c24c0 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/ma/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,1,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["numpy.ma.core","numpy.ma.extras","builtins","_frozen_importlib","abc","typing"],"hash":"c433cea62c01ee0305863ab5afdccb38ae2498a7","id":"numpy.ma","ignore_all":true,"interface_hash":"92738265512c331823eec24a4e68bf01607a5543","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/ma/__init__.pyi","plugin_data":null,"size":6946,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/ma/core.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/ma/core.data.json new file mode 100644 index 0000000000000000000000000000000000000000..128d4167d91c98e36d5b25ca8bf3d375c6f2ed89 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/ma/core.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.ma.core","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"Incomplete":{".class":"SymbolTableNode","cross_ref":"_typeshed.Incomplete","kind":"Gdef","module_hidden":true,"module_public":false},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"MAError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.Exception"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.ma.core.MAError","name":"MAError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MAError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.ma.core","mro":["numpy.ma.core.MAError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core.MAError.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.ma.core.MAError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"MaskError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy.ma.core.MAError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.ma.core.MaskError","name":"MaskError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.ma.core","mro":["numpy.ma.core.MaskError","numpy.ma.core.MAError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core.MaskError.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.ma.core.MaskError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"MaskType":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy.ma.core.MaskType","line":252,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}}},"MaskedArray":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ndarray"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.ma.core.MaskedArray","name":"MaskedArray","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.ma.core","mro":["numpy.ma.core.MaskedArray","numpy.ndarray","numpy._ArrayOrScalarCommon","builtins.object"],"names":{".class":"SymbolTable","__add__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.__add__","name":"__add__","original_first_arg":"self","type":null}},"__array_finalize__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.__array_finalize__","name":"__array_finalize__","original_first_arg":"self","type":null}},"__array_priority__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.core.MaskedArray.__array_priority__","name":"__array_priority__","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"__array_wrap__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","obj","context","return_scalar"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.__array_wrap__","name":"__array_wrap__","original_first_arg":"self","type":null}},"__deepcopy__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","memo"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.__deepcopy__","name":"__deepcopy__","original_first_arg":"self","type":null}},"__eq__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.__eq__","name":"__eq__","original_first_arg":"self","type":null}},"__floordiv__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.__floordiv__","name":"__floordiv__","original_first_arg":"self","type":null}},"__ge__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.__ge__","name":"__ge__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ge__ of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__getitem__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.__getitem__","name":"__getitem__","original_first_arg":"self","type":null}},"__gt__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.__gt__","name":"__gt__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__gt__ of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__iadd__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.__iadd__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.__iadd__","name":"__iadd__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iadd__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.__iadd__","name":"__iadd__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iadd__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.__iadd__","name":"__iadd__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iadd__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.__iadd__","name":"__iadd__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iadd__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.__iadd__","name":"__iadd__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iadd__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.__iadd__","name":"__iadd__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iadd__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.__iadd__","name":"__iadd__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iadd__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.__iadd__","name":"__iadd__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iadd__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.__iadd__","name":"__iadd__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iadd__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.__iadd__","name":"__iadd__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iadd__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.__iadd__","name":"__iadd__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iadd__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.__iadd__","name":"__iadd__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iadd__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.__iadd__","name":"__iadd__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"Instance","args":["numpy.str_"],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.dtypes.Never","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtypes.StringDType"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iadd__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.__iadd__","name":"__iadd__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"Instance","args":["numpy.str_"],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.dtypes.Never","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtypes.StringDType"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iadd__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.__iadd__","name":"__iadd__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iadd__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.__iadd__","name":"__iadd__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iadd__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iadd__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iadd__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iadd__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iadd__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iadd__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iadd__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"Instance","args":["numpy.str_"],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.dtypes.Never","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtypes.StringDType"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iadd__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iadd__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"__ifloordiv__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.__ifloordiv__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.__ifloordiv__","name":"__ifloordiv__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ifloordiv__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.__ifloordiv__","name":"__ifloordiv__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ifloordiv__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.__ifloordiv__","name":"__ifloordiv__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ifloordiv__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.__ifloordiv__","name":"__ifloordiv__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ifloordiv__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.__ifloordiv__","name":"__ifloordiv__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ifloordiv__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.__ifloordiv__","name":"__ifloordiv__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ifloordiv__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ifloordiv__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ifloordiv__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ifloordiv__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"__imul__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.__imul__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.__imul__","name":"__imul__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__imul__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.__imul__","name":"__imul__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__imul__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.__imul__","name":"__imul__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.dtypes.Never","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtypes.StringDType"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__imul__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.__imul__","name":"__imul__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.dtypes.Never","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtypes.StringDType"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__imul__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.__imul__","name":"__imul__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__imul__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.__imul__","name":"__imul__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__imul__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.__imul__","name":"__imul__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__imul__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.__imul__","name":"__imul__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__imul__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.__imul__","name":"__imul__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__imul__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.__imul__","name":"__imul__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__imul__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__imul__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.character"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.dtypes.Never","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtypes.StringDType"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__imul__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__imul__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__imul__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__imul__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"__ipow__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.__ipow__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.__ipow__","name":"__ipow__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ipow__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.__ipow__","name":"__ipow__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ipow__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.__ipow__","name":"__ipow__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ipow__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.__ipow__","name":"__ipow__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ipow__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.__ipow__","name":"__ipow__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ipow__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.__ipow__","name":"__ipow__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ipow__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.__ipow__","name":"__ipow__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ipow__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.__ipow__","name":"__ipow__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ipow__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ipow__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ipow__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ipow__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ipow__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"__isub__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.__isub__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.__isub__","name":"__isub__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__isub__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.__isub__","name":"__isub__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__isub__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.__isub__","name":"__isub__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__isub__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.__isub__","name":"__isub__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__isub__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.__isub__","name":"__isub__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__isub__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.__isub__","name":"__isub__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__isub__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.__isub__","name":"__isub__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__isub__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.__isub__","name":"__isub__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__isub__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.__isub__","name":"__isub__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__isub__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.__isub__","name":"__isub__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__isub__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__isub__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__isub__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__isub__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__isub__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__isub__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"__itruediv__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.__itruediv__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.__itruediv__","name":"__itruediv__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__itruediv__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.__itruediv__","name":"__itruediv__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__itruediv__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.__itruediv__","name":"__itruediv__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__itruediv__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.__itruediv__","name":"__itruediv__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__itruediv__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.__itruediv__","name":"__itruediv__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__itruediv__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.__itruediv__","name":"__itruediv__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__itruediv__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__itruediv__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__itruediv__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__itruediv__ of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"__le__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.__le__","name":"__le__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__le__ of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__lt__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.__lt__","name":"__lt__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__lt__ of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__mul__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.__mul__","name":"__mul__","original_first_arg":"self","type":null}},"__ne__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.__ne__","name":"__ne__","original_first_arg":"self","type":null}},"__new__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1,1,1,1,1,1],"arg_names":["cls","data","mask","dtype","copy","subok","ndmin","fill_value","keep_mask","hard_mask","shrink","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static"],"fullname":"numpy.ma.core.MaskedArray.__new__","name":"__new__","original_first_arg":"cls","type":null}},"__pow__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":[null,null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.__pow__","name":"__pow__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":[null,null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__pow__ of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__radd__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.__radd__","name":"__radd__","original_first_arg":"self","type":null}},"__reduce__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.__reduce__","name":"__reduce__","original_first_arg":"self","type":null}},"__rfloordiv__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.__rfloordiv__","name":"__rfloordiv__","original_first_arg":"self","type":null}},"__rmul__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.__rmul__","name":"__rmul__","original_first_arg":"self","type":null}},"__rpow__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":[null,null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.__rpow__","name":"__rpow__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":[null,null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__rpow__ of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__rsub__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.__rsub__","name":"__rsub__","original_first_arg":"self","type":null}},"__rtruediv__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.__rtruediv__","name":"__rtruediv__","original_first_arg":"self","type":null}},"__setitem__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":[null,null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.__setitem__","name":"__setitem__","original_first_arg":"self","type":null}},"__setmask__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","mask","copy"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.__setmask__","name":"__setmask__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","mask","copy"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__setmask__ of MaskedArray","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__sub__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.__sub__","name":"__sub__","original_first_arg":"self","type":null}},"__truediv__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.__truediv__","name":"__truediv__","original_first_arg":"self","type":null}},"all":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.all","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","axis","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.all","name":"all","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","axis","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"all of MaskedArray","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.all","name":"all","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","axis","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"all of MaskedArray","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,3],"arg_names":["self","axis","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.all","name":"all","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,3],"arg_names":["self","axis","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"all of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.all","name":"all","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,3],"arg_names":["self","axis","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"all of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","axis","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.all","name":"all","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","axis","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"all of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.all","name":"all","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","axis","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"all of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","axis","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.all","name":"all","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","axis","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"all of MaskedArray","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.all","name":"all","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","axis","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"all of MaskedArray","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3,5],"arg_names":["self","axis","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.all","name":"all","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["self","axis","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.all#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"all of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.all#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.all#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.all","name":"all","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["self","axis","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.all#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"all of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.all#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.all#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","axis","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.all","name":"all","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","axis","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.all","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"all of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.all","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.all","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.all","name":"all","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","axis","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.all","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"all of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.all","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.all","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","axis","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"all of MaskedArray","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,3],"arg_names":["self","axis","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"all of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","axis","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"all of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","axis","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"all of MaskedArray","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["self","axis","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.all#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"all of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.all#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.all#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","axis","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.all","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"all of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.all","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.all","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"anom":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["self","axis","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.anom","name":"anom","original_first_arg":"self","type":null}},"any":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.any","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","axis","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.any","name":"any","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","axis","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"any of MaskedArray","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.any","name":"any","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","axis","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"any of MaskedArray","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,3],"arg_names":["self","axis","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.any","name":"any","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,3],"arg_names":["self","axis","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"any of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.any","name":"any","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,3],"arg_names":["self","axis","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"any of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","axis","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.any","name":"any","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","axis","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"any of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.any","name":"any","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","axis","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"any of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","axis","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.any","name":"any","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","axis","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"any of MaskedArray","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.any","name":"any","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","axis","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"any of MaskedArray","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3,5],"arg_names":["self","axis","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.any","name":"any","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["self","axis","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.any#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"any of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.any#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.any#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.any","name":"any","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["self","axis","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.any#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"any of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.any#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.any#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","axis","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.any","name":"any","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","axis","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.any","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"any of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.any","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.any","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.any","name":"any","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","axis","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.any","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"any of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.any","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.any","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","axis","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"any of MaskedArray","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,3],"arg_names":["self","axis","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"any of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","axis","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"any of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","axis","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"any of MaskedArray","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":["self","axis","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.any#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"any of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.any#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.any#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","axis","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.any","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"any of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.any","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.any","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"argmax":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.argmax","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,5],"arg_names":["self","axis","fill_value","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.argmax","name":"argmax","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmax of MaskedArray","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.argmax","name":"argmax","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmax of MaskedArray","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,5],"arg_names":["self","axis","fill_value","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.argmax","name":"argmax","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmax of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.argmax","name":"argmax","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmax of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,3,5],"arg_names":["self","axis","fill_value","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.argmax","name":"argmax","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.argmax#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmax of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.argmax#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.argmax#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.argmax","name":"argmax","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.argmax#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmax of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.argmax#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.argmax#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,5],"arg_names":["self","axis","fill_value","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.argmax","name":"argmax","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.argmax","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmax of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.argmax","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.argmax","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.argmax","name":"argmax","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.argmax","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmax of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.argmax","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.argmax","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmax of MaskedArray","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmax of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.argmax#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmax of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.argmax#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.argmax#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,0,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.argmax","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmax of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.argmax","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.argmax","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"argmin":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.argmin","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,5],"arg_names":["self","axis","fill_value","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.argmin","name":"argmin","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmin of MaskedArray","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.argmin","name":"argmin","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmin of MaskedArray","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,5],"arg_names":["self","axis","fill_value","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.argmin","name":"argmin","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmin of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.argmin","name":"argmin","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmin of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,3,5],"arg_names":["self","axis","fill_value","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.argmin","name":"argmin","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.argmin#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmin of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.argmin#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.argmin#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.argmin","name":"argmin","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.argmin#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmin of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.argmin#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.argmin#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,5],"arg_names":["self","axis","fill_value","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.argmin","name":"argmin","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.argmin","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmin of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.argmin","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.argmin","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.argmin","name":"argmin","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.argmin","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmin of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.argmin","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.argmin","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmin of MaskedArray","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmin of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.argmin#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmin of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.argmin#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.argmin#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,0,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.argmin","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmin of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.argmin","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.argmin","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"argpartition":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.argpartition","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":[null,"kth","axis","kind","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.argpartition","name":"argpartition","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":[null,"kth","axis","kind","order"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argpartition of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.argpartition","name":"argpartition","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":[null,"kth","axis","kind","order"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argpartition of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":[null,"kth","axis","kind","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.argpartition","name":"argpartition","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":[null,"kth","axis","kind","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argpartition of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.argpartition","name":"argpartition","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":[null,"kth","axis","kind","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argpartition of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":[null,"kth","axis","kind","order"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argpartition of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":[null,"kth","axis","kind","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argpartition of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"argsort":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,5],"arg_names":["self","axis","kind","order","endwith","fill_value","stable"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.argsort","name":"argsort","original_first_arg":"self","type":null}},"baseclass":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.baseclass","name":"baseclass","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"baseclass of MaskedArray","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.baseclass","name":"baseclass","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"baseclass of MaskedArray","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"compress":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","condition","axis","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.compress","name":"compress","original_first_arg":"self","type":null}},"compressed":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.compressed","name":"compressed","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"compressed of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"copy":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.core.MaskedArray.copy","name":"copy","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"count":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.count","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["self","axis","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.count","name":"count","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","axis","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count of MaskedArray","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.count","name":"count","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","axis","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count of MaskedArray","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","axis","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.count","name":"count","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","axis","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.count","name":"count","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","axis","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3],"arg_names":["self","axis","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.count","name":"count","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,3],"arg_names":["self","axis","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.count","name":"count","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3],"arg_names":["self","axis","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","axis","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.count","name":"count","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","axis","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.count","name":"count","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","axis","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","axis","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count of MaskedArray","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","axis","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,3],"arg_names":["self","axis","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","axis","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"cumprod":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","axis","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.cumprod","name":"cumprod","original_first_arg":"self","type":null}},"cumsum":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","axis","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.cumsum","name":"cumsum","original_first_arg":"self","type":null}},"data":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.core.MaskedArray.data","name":"data","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"diagonal":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.core.MaskedArray.diagonal","name":"diagonal","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"dot":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","b","out","strict"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.dot","name":"dot","original_first_arg":"self","type":null}},"dtype":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":["is_property"],"fullname":"numpy.ma.core.MaskedArray.dtype","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.dtype","name":"dtype","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dtype of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_settable_property","is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.dtype","name":"dtype","setter_type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy.ma.core.MaskedArray.dtype","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy.ma.core.MaskedArray.dtype","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dtype of MaskedArray","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy.ma.core.MaskedArray.dtype","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}]},"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dtype of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated"],"fullname":"numpy.ma.core.MaskedArray.dtype","name":"dtype","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy.ma.core.MaskedArray.dtype","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy.ma.core.MaskedArray.dtype","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dtype of MaskedArray","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy.ma.core.MaskedArray.dtype","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"","name":"dtype","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy.ma.core.MaskedArray.dtype","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy.ma.core.MaskedArray.dtype","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dtype of MaskedArray","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._DTypeT","id":-1,"name":"_DTypeT","namespace":"numpy.ma.core.MaskedArray.dtype","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}]}}}],"setter_index":1,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dtype of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"fill_value":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":["is_property"],"fullname":"numpy.ma.core.MaskedArray.fill_value","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.fill_value","name":"fill_value","original_first_arg":"self","type":null},"is_overload":true,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_settable_property","is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.fill_value","name":"fill_value","setter_type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","value"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":true,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fill_value of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":true,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fill_value of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated"],"fullname":"numpy.ma.core.MaskedArray.fill_value","name":"fill_value","original_first_arg":"self","type":null},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"","name":"fill_value","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","value"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":true,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fill_value of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":1,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":true,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fill_value of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"filled":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":[null,"fill_value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.filled","name":"filled","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":[null,"fill_value"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"filled of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"flat":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":["is_property"],"fullname":"numpy.ma.core.MaskedArray.flat","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.flat","name":"flat","original_first_arg":"self","type":null},"is_overload":true,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_settable_property","is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.flat","name":"flat","setter_type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","value"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":true,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"flat of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":true,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"flat of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated"],"fullname":"numpy.ma.core.MaskedArray.flat","name":"flat","original_first_arg":"self","type":null},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"","name":"flat","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","value"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":true,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"flat of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":1,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":true,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"flat of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"flatten":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.core.MaskedArray.flatten","name":"flatten","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"get_fill_value":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.core.MaskedArray.get_fill_value","name":"get_fill_value","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"get_imag":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.core.MaskedArray.get_imag","name":"get_imag","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"get_real":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.core.MaskedArray.get_real","name":"get_real","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"harden_mask":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.harden_mask","name":"harden_mask","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"harden_mask of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"hardmask":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.hardmask","name":"hardmask","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hardmask of MaskedArray","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.hardmask","name":"hardmask","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hardmask of MaskedArray","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"ids":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.ids","name":"ids","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ids of MaskedArray","ret_type":{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"imag":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.imag","name":"imag","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":["builtins.object",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.imag","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._HasDTypeWithRealAndImag"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"imag of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.imag","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.imag","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.imag","name":"imag","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":["builtins.object",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.imag","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy._HasDTypeWithRealAndImag"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"imag of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.imag","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.imag","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}}},"iscontiguous":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.iscontiguous","name":"iscontiguous","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"iscontiguous of MaskedArray","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"mask":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":["is_property"],"fullname":"numpy.ma.core.MaskedArray.mask","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.mask","name":"mask","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mask of MaskedArray","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_settable_property","is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.mask","name":"mask","setter_type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mask of MaskedArray","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mask of MaskedArray","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.mask","name":"mask","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mask of MaskedArray","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"","name":"mask","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mask of MaskedArray","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":1,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mask of MaskedArray","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"max":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.max","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["self","axis","out","fill_value","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.max","name":"max","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["self","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"max of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.max#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.max#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.max","name":"max","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["self","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"max of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.max#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.max#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["self","axis","out","fill_value","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.max","name":"max","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["self","axis","out","fill_value","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"max of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.max","name":"max","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["self","axis","out","fill_value","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"max of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1],"arg_names":["self","axis","out","fill_value","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.max","name":"max","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1],"arg_names":["self","axis","out","fill_value","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.max#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"max of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.max#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.max#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.max","name":"max","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1],"arg_names":["self","axis","out","fill_value","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.max#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"max of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.max#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.max#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3,5,5],"arg_names":["self","axis","out","fill_value","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.max","name":"max","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,3,5,5],"arg_names":["self","axis","out","fill_value","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.max","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"max of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.max","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.max","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.max","name":"max","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3,5,5],"arg_names":["self","axis","out","fill_value","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.max","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"max of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.max","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.max","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["self","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"max of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.max#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.max#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["self","axis","out","fill_value","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"max of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1],"arg_names":["self","axis","out","fill_value","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.max#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"max of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.max#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.max#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5,5],"arg_names":["self","axis","out","fill_value","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.max","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"max of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.max","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.max","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"mean":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["self","axis","dtype","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.mean","name":"mean","original_first_arg":"self","type":null}},"min":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.min","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["self","axis","out","fill_value","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.min","name":"min","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["self","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"min of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.min#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.min#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.min","name":"min","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["self","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"min of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.min#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.min#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["self","axis","out","fill_value","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.min","name":"min","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["self","axis","out","fill_value","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"min of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.min","name":"min","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["self","axis","out","fill_value","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"min of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1],"arg_names":["self","axis","out","fill_value","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.min","name":"min","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1],"arg_names":["self","axis","out","fill_value","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.min#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"min of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.min#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.min#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.min","name":"min","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1],"arg_names":["self","axis","out","fill_value","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.min#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"min of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.min#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.min#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3,5,5],"arg_names":["self","axis","out","fill_value","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.min","name":"min","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,3,5,5],"arg_names":["self","axis","out","fill_value","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.min","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"min of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.min","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.min","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.min","name":"min","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3,5,5],"arg_names":["self","axis","out","fill_value","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.min","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"min of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.min","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.min","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["self","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"min of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.min#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.min#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["self","axis","out","fill_value","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"min of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1],"arg_names":["self","axis","out","fill_value","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.min#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"min of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.min#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.min#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5,5],"arg_names":["self","axis","out","fill_value","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.min","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"min of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.min","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.min","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"nonzero":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.nonzero","name":"nonzero","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"nonzero of MaskedArray","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnpackType","type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"partition":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.partition","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":[null,"kth","axis","kind","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.partition","name":"partition","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":[null,"kth","axis","kind","order"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition of MaskedArray","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.partition","name":"partition","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":[null,"kth","axis","kind","order"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition of MaskedArray","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":[null,"kth","axis","kind","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.partition","name":"partition","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":[null,"kth","axis","kind","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition of MaskedArray","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.partition","name":"partition","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":[null,"kth","axis","kind","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition of MaskedArray","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":[null,"kth","axis","kind","order"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition of MaskedArray","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":[null,"kth","axis","kind","order"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"partition of MaskedArray","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"prod":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["self","axis","dtype","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.prod","name":"prod","original_first_arg":"self","type":null}},"product":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.core.MaskedArray.product","name":"product","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"ptp":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.ptp","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["self","axis","out","fill_value","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.ptp","name":"ptp","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["self","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ptp of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.ptp#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.ptp#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.ptp","name":"ptp","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["self","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ptp of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.ptp#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.ptp#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["self","axis","out","fill_value","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.ptp","name":"ptp","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["self","axis","out","fill_value","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ptp of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.ptp","name":"ptp","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["self","axis","out","fill_value","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ptp of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1],"arg_names":["self","axis","out","fill_value","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.ptp","name":"ptp","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1],"arg_names":["self","axis","out","fill_value","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.ptp#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ptp of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.ptp#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.ptp#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.ptp","name":"ptp","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1],"arg_names":["self","axis","out","fill_value","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.ptp#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ptp of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.ptp#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.ptp#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3,5,5],"arg_names":["self","axis","out","fill_value","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.ptp","name":"ptp","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,3,5,5],"arg_names":["self","axis","out","fill_value","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.ptp","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ptp of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.ptp","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.ptp","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.ptp","name":"ptp","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3,5,5],"arg_names":["self","axis","out","fill_value","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.ptp","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ptp of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.ptp","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.ptp","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["self","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ptp of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.ptp#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.ptp#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["self","axis","out","fill_value","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ptp of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1],"arg_names":["self","axis","out","fill_value","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.ptp#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ptp of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.ptp#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.ptp#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5,5],"arg_names":["self","axis","out","fill_value","keepdims"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.ptp","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ptp of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.ptp","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.ptp","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"put":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","indices","values","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.put","name":"put","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","indices","values","mode"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"put of MaskedArray","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"ravel":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.ravel","name":"ravel","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","order"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ravel of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"real":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.real","name":"real","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.real","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"builtins.object"],"extra_attrs":null,"type_ref":"numpy._HasDTypeWithRealAndImag"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"real of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.real","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.real","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.real","name":"real","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.real","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"builtins.object"],"extra_attrs":null,"type_ref":"numpy._HasDTypeWithRealAndImag"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"real of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.real","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.real","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}}},"recordmask":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":["is_property"],"fullname":"numpy.ma.core.MaskedArray.recordmask","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.recordmask","name":"recordmask","original_first_arg":"self","type":null},"is_overload":true,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_settable_property","is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.recordmask","name":"recordmask","setter_type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","mask"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":true,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"recordmask of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":true,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"recordmask of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","mask"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated"],"fullname":"numpy.ma.core.MaskedArray.recordmask","name":"recordmask","original_first_arg":"self","type":null},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"","name":"recordmask","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","mask"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":true,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"recordmask of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":1,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":true,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"recordmask of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"repeat":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.repeat","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","repeats","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.repeat","name":"repeat","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","repeats","axis"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"repeat of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.repeat","name":"repeat","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","repeats","axis"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"repeat of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","repeats","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.repeat","name":"repeat","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","repeats","axis"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"repeat of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.repeat","name":"repeat","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","repeats","axis"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"repeat of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","repeats","axis"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"repeat of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","repeats","axis"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"repeat of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"reshape":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":["self","s","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.reshape","name":"reshape","original_first_arg":"self","type":null}},"resize":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","newshape","refcheck","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.resize","name":"resize","original_first_arg":"self","type":null}},"round":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["self","decimals","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.round","name":"round","original_first_arg":"self","type":null}},"set_fill_value":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.core.MaskedArray.set_fill_value","name":"set_fill_value","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"shape":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":["is_property"],"fullname":"numpy.ma.core.MaskedArray.shape","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.shape","name":"shape","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shape of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_settable_property","is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.shape","name":"shape","setter_type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ShapeT","id":-1,"name":"_ShapeT","namespace":"numpy.ma.core.MaskedArray.shape","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ShapeT","id":-1,"name":"_ShapeT","namespace":"numpy.ma.core.MaskedArray.shape","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shape of MaskedArray","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ShapeT","id":-1,"name":"_ShapeT","namespace":"numpy.ma.core.MaskedArray.shape","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]},"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shape of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated"],"fullname":"numpy.ma.core.MaskedArray.shape","name":"shape","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ShapeT","id":-1,"name":"_ShapeT","namespace":"numpy.ma.core.MaskedArray.shape","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ShapeT","id":-1,"name":"_ShapeT","namespace":"numpy.ma.core.MaskedArray.shape","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shape of MaskedArray","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ShapeT","id":-1,"name":"_ShapeT","namespace":"numpy.ma.core.MaskedArray.shape","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"","name":"shape","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ShapeT","id":-1,"name":"_ShapeT","namespace":"numpy.ma.core.MaskedArray.shape","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ShapeT","id":-1,"name":"_ShapeT","namespace":"numpy.ma.core.MaskedArray.shape","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shape of MaskedArray","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ShapeT","id":-1,"name":"_ShapeT","namespace":"numpy.ma.core.MaskedArray.shape","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}]}}}],"setter_index":1,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shape of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"sharedmask":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.sharedmask","name":"sharedmask","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sharedmask of MaskedArray","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.sharedmask","name":"sharedmask","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sharedmask of MaskedArray","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"shrink_mask":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.shrink_mask","name":"shrink_mask","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shrink_mask of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"soften_mask":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.soften_mask","name":"soften_mask","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"soften_mask of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"sort":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,5],"arg_names":["self","axis","kind","order","endwith","fill_value","stable"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.sort","name":"sort","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,5],"arg_names":["self","axis","kind","order","endwith","fill_value","stable"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sort of MaskedArray","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"squeeze":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.core.MaskedArray.squeeze","name":"squeeze","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"std":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1],"arg_names":["self","axis","dtype","out","ddof","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.std","name":"std","original_first_arg":"self","type":null}},"sum":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["self","axis","dtype","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.sum","name":"sum","original_first_arg":"self","type":null}},"swapaxes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":[null,null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.swapaxes","name":"swapaxes","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"typing.SupportsIndex","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"swapaxes of MaskedArray","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"take":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.take","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["self","indices","axis","out","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.take","name":"take","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.take#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.take#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.take","name":"take","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.take#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.take#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["self","indices","axis","out","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.MaskedArray.take","name":"take","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.take#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.take","name":"take","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.take#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1],"arg_names":["self","indices","axis","out","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.take","name":"take","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","indices","axis","out","mode"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.take#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.take#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.take#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.take","name":"take","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","indices","axis","out","mode"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.take#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.take#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.take#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,3,5],"arg_names":["self","indices","axis","out","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.take","name":"take","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,3,5],"arg_names":["self","indices","axis","out","mode"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.take","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.take","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.take","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.MaskedArray.take","name":"take","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,3,5],"arg_names":["self","indices","axis","out","mode"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.take","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.take","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.take","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.take#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.take#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.MaskedArray.take#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","indices","axis","out","mode"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.take#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.take#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.take#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,3,5],"arg_names":["self","indices","axis","out","mode"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.take","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take of MaskedArray","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.take","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.MaskedArray.take","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"tobytes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":[null,"fill_value","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.tobytes","name":"tobytes","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":[null,"fill_value","order"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tobytes of MaskedArray","ret_type":"builtins.bytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"tofile":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":[null,"fid","sep","format"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.tofile","name":"tofile","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":[null,"fid","sep","format"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},"builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tofile of MaskedArray","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"toflex":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.toflex","name":"toflex","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"toflex of MaskedArray","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"tolist":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","fill_value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.tolist","name":"tolist","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","fill_value"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tolist of MaskedArray","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"torecords":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.torecords","name":"torecords","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"torecords of MaskedArray","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"trace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1],"arg_names":["self","offset","axis1","axis2","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.trace","name":"trace","original_first_arg":"self","type":null}},"unshare_mask":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.ma.core.MaskedArray.unshare_mask","name":"unshare_mask","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unshare_mask of MaskedArray","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"var":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1],"arg_names":["self","axis","dtype","out","ddof","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.var","name":"var","original_first_arg":"self","type":null}},"view":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","dtype","type","fill_value"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArray.view","name":"view","original_first_arg":"self","type":null}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core.MaskedArray.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.MaskedArray","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_ShapeT_co","_DTypeT_co"],"typeddict_type":null}},"MaskedArrayFutureWarning":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.FutureWarning"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.ma.core.MaskedArrayFutureWarning","name":"MaskedArrayFutureWarning","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedArrayFutureWarning","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.ma.core","mro":["numpy.ma.core.MaskedArrayFutureWarning","builtins.FutureWarning","builtins.Warning","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core.MaskedArrayFutureWarning.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.ma.core.MaskedArrayFutureWarning","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"MaskedConstant":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["numpy.float64"],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.ma.core.MaskedConstant","name":"MaskedConstant","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedConstant","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.ma.core","mro":["numpy.ma.core.MaskedConstant","numpy.ma.core.MaskedArray","numpy.ndarray","numpy._ArrayOrScalarCommon","builtins.object"],"names":{".class":"SymbolTable","__array_finalize__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedConstant.__array_finalize__","name":"__array_finalize__","original_first_arg":"self","type":null}},"__array_wrap__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","obj","context","return_scalar"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedConstant.__array_wrap__","name":"__array_wrap__","original_first_arg":"self","type":null}},"__class__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.core.MaskedConstant.__class__","name":"__class__","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"__copy__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedConstant.__copy__","name":"__copy__","original_first_arg":"self","type":null}},"__deepcopy__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","memo"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedConstant.__deepcopy__","name":"__deepcopy__","original_first_arg":"self","type":null}},"__format__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","format_spec"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedConstant.__format__","name":"__format__","original_first_arg":"self","type":null}},"__iadd__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.core.MaskedConstant.__iadd__","name":"__iadd__","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"__ifloordiv__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.core.MaskedConstant.__ifloordiv__","name":"__ifloordiv__","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"__imul__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.core.MaskedConstant.__imul__","name":"__imul__","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"__iop__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","other"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedConstant.__iop__","name":"__iop__","original_first_arg":"self","type":null}},"__ipow__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.core.MaskedConstant.__ipow__","name":"__ipow__","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"__isub__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.core.MaskedConstant.__isub__","name":"__isub__","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"__itruediv__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.core.MaskedConstant.__itruediv__","name":"__itruediv__","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"__new__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static"],"fullname":"numpy.ma.core.MaskedConstant.__new__","name":"__new__","original_first_arg":"cls","type":null}},"__reduce__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedConstant.__reduce__","name":"__reduce__","original_first_arg":"self","type":null}},"__setattr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","attr","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedConstant.__setattr__","name":"__setattr__","original_first_arg":"self","type":null}},"copy":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedConstant.copy","name":"copy","original_first_arg":"self","type":null}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core.MaskedConstant.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.ma.core.MaskedConstant","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"MaskedIterator":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.ma.core.MaskedIterator","name":"MaskedIterator","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedIterator","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.ma.core","mro":["numpy.ma.core.MaskedIterator","builtins.object"],"names":{".class":"SymbolTable","__getitem__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedIterator.__getitem__","name":"__getitem__","original_first_arg":"self","type":null}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","ma"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedIterator.__init__","name":"__init__","original_first_arg":"self","type":null}},"__iter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedIterator.__iter__","name":"__iter__","original_first_arg":"self","type":null}},"__next__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedIterator.__next__","name":"__next__","original_first_arg":"self","type":null}},"__setitem__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":[null,null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.MaskedIterator.__setitem__","name":"__setitem__","original_first_arg":"self","type":null}},"dataiter":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.core.MaskedIterator.dataiter","name":"dataiter","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"ma":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.core.MaskedIterator.ma","name":"ma","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"maskiter":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.core.MaskedIterator.maskiter","name":"maskiter","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core.MaskedIterator.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.ma.core.MaskedIterator","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"Self":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.ma.core.Self","name":"Self","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.ma.core.Self","source_any":null,"type_of_any":3}}},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef","module_hidden":true,"module_public":false},"SupportsIndex":{".class":"SymbolTableNode","cross_ref":"typing.SupportsIndex","kind":"Gdef","module_hidden":true,"module_public":false},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.ma.core.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3}}},"TypeIs":{".class":"SymbolTableNode","cross_ref":"typing_extensions.TypeIs","kind":"Gdef","module_hidden":true,"module_public":false},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing_extensions.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"_AnyShape":{".class":"SymbolTableNode","cross_ref":"numpy._typing._shape._AnyShape","kind":"Gdef","module_hidden":true,"module_public":false},"_Array1D":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.ma.core._Array1D","name":"_Array1D","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3}}},"_ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeBool_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeBool_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeBytes_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeBytes_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeComplex_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeComplex_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeFloat_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeFloat_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeInt":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeInt","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeInt_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeInt_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeStr_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeStr_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeString_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeString_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeTD64_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeTD64_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","name":"_ArrayT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}},"_DTypeLikeBool":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._DTypeLikeBool","kind":"Gdef","module_hidden":true,"module_public":false},"_DTypeT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._DTypeT","name":"_DTypeT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":0}},"_DTypeT_co":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","name":"_DTypeT_co","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}},"_DomainedBinaryOperation":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy.ma.core._MaskedUFunc"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.ma.core._DomainedBinaryOperation","name":"_DomainedBinaryOperation","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.ma.core._DomainedBinaryOperation","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.ma.core","mro":["numpy.ma.core._DomainedBinaryOperation","numpy.ma.core._MaskedUFunc","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,2,4],"arg_names":["self","a","b","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core._DomainedBinaryOperation.__call__","name":"__call__","original_first_arg":"self","type":null}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1],"arg_names":["self","dbfunc","domain","fillx","filly"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core._DomainedBinaryOperation.__init__","name":"__init__","original_first_arg":"self","type":null}},"domain":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.core._DomainedBinaryOperation.domain","name":"domain","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"fillx":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.core._DomainedBinaryOperation.fillx","name":"fillx","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"filly":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.core._DomainedBinaryOperation.filly","name":"filly","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._DomainedBinaryOperation.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.ma.core._DomainedBinaryOperation","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_HasDTypeWithRealAndImag":{".class":"SymbolTableNode","cross_ref":"numpy._HasDTypeWithRealAndImag","kind":"Gdef","module_hidden":true,"module_public":false},"_IntLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._IntLike_co","kind":"Gdef","module_hidden":true,"module_public":false},"_MaskedArray":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.ma.core._MaskedArray","name":"_MaskedArray","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3}}},"_MaskedBinaryOperation":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy.ma.core._MaskedUFunc"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.ma.core._MaskedBinaryOperation","name":"_MaskedBinaryOperation","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.ma.core._MaskedBinaryOperation","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.ma.core","mro":["numpy.ma.core._MaskedBinaryOperation","numpy.ma.core._MaskedUFunc","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,2,4],"arg_names":["self","a","b","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core._MaskedBinaryOperation.__call__","name":"__call__","original_first_arg":"self","type":null}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","mbfunc","fillx","filly"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core._MaskedBinaryOperation.__init__","name":"__init__","original_first_arg":"self","type":null}},"accumulate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","target","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core._MaskedBinaryOperation.accumulate","name":"accumulate","original_first_arg":"self","type":null}},"fillx":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.core._MaskedBinaryOperation.fillx","name":"fillx","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"filly":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.core._MaskedBinaryOperation.filly","name":"filly","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"outer":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","a","b"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core._MaskedBinaryOperation.outer","name":"outer","original_first_arg":"self","type":null}},"reduce":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","target","axis","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core._MaskedBinaryOperation.reduce","name":"reduce","original_first_arg":"self","type":null}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._MaskedBinaryOperation.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.ma.core._MaskedBinaryOperation","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_MaskedPrintOption":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.ma.core._MaskedPrintOption","name":"_MaskedPrintOption","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.ma.core._MaskedPrintOption","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.ma.core","mro":["numpy.ma.core._MaskedPrintOption","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","display"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core._MaskedPrintOption.__init__","name":"__init__","original_first_arg":"self","type":null}},"display":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core._MaskedPrintOption.display","name":"display","original_first_arg":"self","type":null}},"enable":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","shrink"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core._MaskedPrintOption.enable","name":"enable","original_first_arg":"self","type":null}},"enabled":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core._MaskedPrintOption.enabled","name":"enabled","original_first_arg":"self","type":null}},"set_display":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","s"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core._MaskedPrintOption.set_display","name":"set_display","original_first_arg":"self","type":null}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._MaskedPrintOption.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.ma.core._MaskedPrintOption","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_MaskedUFunc":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.ma.core._MaskedUFunc","name":"_MaskedUFunc","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.ma.core._MaskedUFunc","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.ma.core","mro":["numpy.ma.core._MaskedUFunc","builtins.object"],"names":{".class":"SymbolTable","__doc__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.core._MaskedUFunc.__doc__","name":"__doc__","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","ufunc"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core._MaskedUFunc.__init__","name":"__init__","original_first_arg":"self","type":null}},"__name__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.core._MaskedUFunc.__name__","name":"__name__","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"f":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.core._MaskedUFunc.f","name":"f","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._MaskedUFunc.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.ma.core._MaskedUFunc","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_MaskedUnaryOperation":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy.ma.core._MaskedUFunc"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.ma.core._MaskedUnaryOperation","name":"_MaskedUnaryOperation","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.ma.core._MaskedUnaryOperation","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.ma.core","mro":["numpy.ma.core._MaskedUnaryOperation","numpy.ma.core._MaskedUFunc","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,2,4],"arg_names":["self","a","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core._MaskedUnaryOperation.__call__","name":"__call__","original_first_arg":"self","type":null}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","mufunc","fill","domain"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core._MaskedUnaryOperation.__init__","name":"__init__","original_first_arg":"self","type":null}},"domain":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.core._MaskedUnaryOperation.domain","name":"domain","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"fill":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.core._MaskedUnaryOperation.fill","name":"fill","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._MaskedUnaryOperation.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.ma.core._MaskedUnaryOperation","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_ModeKind":{".class":"SymbolTableNode","cross_ref":"numpy._ModeKind","kind":"Gdef","module_hidden":true,"module_public":false},"_NoValueType":{".class":"SymbolTableNode","cross_ref":"numpy._globals._NoValueType","kind":"Gdef","module_hidden":true,"module_public":false},"_OrderKACF":{".class":"SymbolTableNode","cross_ref":"numpy._OrderKACF","kind":"Gdef","module_hidden":true,"module_public":false},"_PartitionKind":{".class":"SymbolTableNode","cross_ref":"numpy._PartitionKind","kind":"Gdef","module_hidden":true,"module_public":false},"_ScalarLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._ScalarLike_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ScalarT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","name":"_ScalarT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}},"_ScalarT_co":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT_co","name":"_ScalarT_co","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}},"_Shape":{".class":"SymbolTableNode","cross_ref":"numpy._typing._shape._Shape","kind":"Gdef","module_hidden":true,"module_public":false},"_ShapeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._shape._ShapeLike","kind":"Gdef","module_hidden":true,"module_public":false},"_ShapeT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ShapeT","name":"_ShapeT","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":0}},"_ShapeT_co":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","name":"_ShapeT_co","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1}},"_SortKind":{".class":"SymbolTableNode","cross_ref":"numpy._SortKind","kind":"Gdef","module_hidden":true,"module_public":false},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.ma.core.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_convert2ma":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.ma.core._convert2ma","name":"_convert2ma","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.ma.core._convert2ma","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.ma.core","mro":["numpy.ma.core._convert2ma","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":[null,"args","params"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.ma.core._convert2ma.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":[null,"args","params"],"arg_types":["numpy.ma.core._convert2ma","builtins.object","builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _convert2ma","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1],"arg_names":[null,"funcname","np_ret","np_ma_ret","params"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.ma.core._convert2ma.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":[null,"funcname","np_ret","np_ma_ret","params"],"arg_types":["numpy.ma.core._convert2ma","builtins.str","builtins.str","builtins.str",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of _convert2ma","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"getdoc":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":[null,"np_ret","np_ma_ret"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.ma.core._convert2ma.getdoc","name":"getdoc","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"np_ret","np_ma_ret"],"arg_types":["numpy.ma.core._convert2ma","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getdoc of _convert2ma","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._convert2ma.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.ma.core._convert2ma","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_extrema_operation":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy.ma.core._MaskedUFunc"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.ma.core._extrema_operation","name":"_extrema_operation","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.ma.core._extrema_operation","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.ma.core","mro":["numpy.ma.core._extrema_operation","numpy.ma.core._MaskedUFunc","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","a","b"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core._extrema_operation.__call__","name":"__call__","original_first_arg":"self","type":null}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","ufunc","compare","fill_value"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core._extrema_operation.__init__","name":"__init__","original_first_arg":"self","type":null}},"compare":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.core._extrema_operation.compare","name":"compare","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"fill_value_func":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.core._extrema_operation.fill_value_func","name":"fill_value_func","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"outer":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","a","b"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core._extrema_operation.outer","name":"outer","original_first_arg":"self","type":null}},"reduce":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","target","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core._extrema_operation.reduce","name":"reduce","original_first_arg":"self","type":null}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._extrema_operation.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.ma.core._extrema_operation","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_frommethod":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.ma.core._frommethod","name":"_frommethod","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.ma.core._frommethod","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.ma.core","mro":["numpy.ma.core._frommethod","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,2,4],"arg_names":["self","a","args","params"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core._frommethod.__call__","name":"__call__","original_first_arg":"self","type":null}},"__doc__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.core._frommethod.__doc__","name":"__doc__","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","methodname","reversed"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core._frommethod.__init__","name":"__init__","original_first_arg":"self","type":null}},"__name__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.core._frommethod.__name__","name":"__name__","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"getdoc":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core._frommethod.getdoc","name":"getdoc","original_first_arg":"self","type":null}},"reversed":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.core._frommethod.reversed","name":"reversed","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._frommethod.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.ma.core._frommethod","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"abs":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.abs","name":"abs","setter_type":null,"type":"numpy.ma.core._MaskedUnaryOperation"}},"absolute":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.absolute","name":"absolute","setter_type":null,"type":"numpy.ma.core._MaskedUnaryOperation"}},"add":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.add","name":"add","setter_type":null,"type":"numpy.ma.core._MaskedBinaryOperation"}},"all":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.all","name":"all","setter_type":null,"type":"numpy.ma.core._frommethod"}},"allclose":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["a","b","masked_equal","rtol","atol"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.allclose","name":"allclose","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","b","masked_equal","rtol","atol"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool","builtins.float","builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"allclose","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"allequal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","b","fill_value"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.allequal","name":"allequal","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","fill_value"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"allequal","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"alltrue":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["target","axis","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.alltrue","name":"alltrue","original_first_arg":"target","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["target","axis","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"alltrue","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"amax":{".class":"SymbolTableNode","cross_ref":"numpy._core.fromnumeric.amax","kind":"Gdef"},"amin":{".class":"SymbolTableNode","cross_ref":"numpy._core.fromnumeric.amin","kind":"Gdef"},"angle":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.angle","name":"angle","setter_type":null,"type":"numpy.ma.core._MaskedUnaryOperation"}},"anom":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.anom","name":"anom","setter_type":null,"type":"numpy.ma.core._frommethod"}},"anomalies":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.anomalies","name":"anomalies","setter_type":null,"type":"numpy.ma.core._frommethod"}},"any":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.any","name":"any","setter_type":null,"type":"numpy.ma.core._frommethod"}},"append":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","b","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.append","name":"append","original_first_arg":"a","type":null}},"arange":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.arange","name":"arange","setter_type":null,"type":"numpy.ma.core._convert2ma"}},"arccos":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.arccos","name":"arccos","setter_type":null,"type":"numpy.ma.core._MaskedUnaryOperation"}},"arccosh":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.arccosh","name":"arccosh","setter_type":null,"type":"numpy.ma.core._MaskedUnaryOperation"}},"arcsin":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.arcsin","name":"arcsin","setter_type":null,"type":"numpy.ma.core._MaskedUnaryOperation"}},"arcsinh":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.arcsinh","name":"arcsinh","setter_type":null,"type":"numpy.ma.core._MaskedUnaryOperation"}},"arctan":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.arctan","name":"arctan","setter_type":null,"type":"numpy.ma.core._MaskedUnaryOperation"}},"arctan2":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.arctan2","name":"arctan2","setter_type":null,"type":"numpy.ma.core._MaskedBinaryOperation"}},"arctanh":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.arctanh","name":"arctanh","setter_type":null,"type":"numpy.ma.core._MaskedUnaryOperation"}},"argmax":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.ma.core.argmax","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,5],"arg_names":["self","axis","fill_value","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.argmax","name":"argmax","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmax","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.argmax","name":"argmax","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmax","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,5],"arg_names":["self","axis","fill_value","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.argmax","name":"argmax","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmax","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.argmax","name":"argmax","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmax","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,3,5],"arg_names":["self","axis","fill_value","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.argmax","name":"argmax","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.argmax#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmax","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.argmax#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.argmax#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.argmax","name":"argmax","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.argmax#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmax","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.argmax#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.argmax#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,5],"arg_names":["self","axis","fill_value","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.argmax","name":"argmax","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.argmax","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmax","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.argmax","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.argmax","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.argmax","name":"argmax","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.argmax","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmax","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.argmax","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.argmax","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmax","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmax","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.argmax#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmax","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.argmax#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.argmax#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,0,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.argmax","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmax","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.argmax","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.argmax","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"argmin":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.ma.core.argmin","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,5],"arg_names":["self","axis","fill_value","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.argmin","name":"argmin","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmin","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.argmin","name":"argmin","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmin","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,5],"arg_names":["self","axis","fill_value","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.argmin","name":"argmin","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.argmin","name":"argmin","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,3,5],"arg_names":["self","axis","fill_value","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.argmin","name":"argmin","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.argmin#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmin","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.argmin#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.argmin#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.argmin","name":"argmin","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.argmin#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmin","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.argmin#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.argmin#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,5],"arg_names":["self","axis","fill_value","out","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.argmin","name":"argmin","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.argmin","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmin","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.argmin","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.argmin","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.argmin","name":"argmin","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.argmin","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmin","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.argmin","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.argmin","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmin","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,3,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.argmin#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmin","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.argmin#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.argmin#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,0,5],"arg_names":["self","axis","fill_value","out","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.argmin","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"argmin","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.argmin","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.argmin","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"argsort":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,5],"arg_names":["a","axis","kind","order","endwith","fill_value","stable"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.argsort","name":"argsort","original_first_arg":"a","type":null}},"around":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.around","name":"around","setter_type":null,"type":"numpy.ma.core._MaskedUnaryOperation"}},"array":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1,1,1,1,1],"arg_names":["data","dtype","copy","order","mask","fill_value","keep_mask","hard_mask","shrink","subok","ndmin"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.array","name":"array","original_first_arg":"data","type":null}},"asanyarray":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.asanyarray","name":"asanyarray","original_first_arg":"a","type":null}},"asarray":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["a","dtype","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.asarray","name":"asarray","original_first_arg":"a","type":null}},"bitwise_and":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.bitwise_and","name":"bitwise_and","setter_type":null,"type":"numpy.ma.core._MaskedBinaryOperation"}},"bitwise_or":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.bitwise_or","name":"bitwise_or","setter_type":null,"type":"numpy.ma.core._MaskedBinaryOperation"}},"bitwise_xor":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.bitwise_xor","name":"bitwise_xor","setter_type":null,"type":"numpy.ma.core._MaskedBinaryOperation"}},"bool_":{".class":"SymbolTableNode","cross_ref":"numpy.bool_","kind":"Gdef"},"bytes_":{".class":"SymbolTableNode","cross_ref":"numpy.bytes_","kind":"Gdef","module_hidden":true,"module_public":false},"ceil":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.ceil","name":"ceil","setter_type":null,"type":"numpy.ma.core._MaskedUnaryOperation"}},"character":{".class":"SymbolTableNode","cross_ref":"numpy.character","kind":"Gdef","module_hidden":true,"module_public":false},"choose":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["indices","choices","out","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.choose","name":"choose","original_first_arg":"indices","type":null}},"clip":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.clip","name":"clip","setter_type":null,"type":"numpy.ma.core._convert2ma"}},"common_fill_value":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","b"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.common_fill_value","name":"common_fill_value","original_first_arg":"a","type":null}},"complexfloating":{".class":"SymbolTableNode","cross_ref":"numpy.complexfloating","kind":"Gdef","module_hidden":true,"module_public":false},"compress":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.compress","name":"compress","setter_type":null,"type":"numpy.ma.core._frommethod"}},"compressed":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.ma.core.compressed","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.compressed","name":"compressed","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"compressed","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT_co","id":-1,"name":"_ScalarT_co","namespace":"numpy.ma.core.compressed#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.compressed","name":"compressed","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"compressed","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT_co","id":-1,"name":"_ScalarT_co","namespace":"numpy.ma.core.compressed#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.compressed","name":"compressed","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"compressed","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.compressed","name":"compressed","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"compressed","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"compressed","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT_co","id":-1,"name":"_ScalarT_co","namespace":"numpy.ma.core.compressed#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"compressed","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"concatenate":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["arrays","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.concatenate","name":"concatenate","original_first_arg":"arrays","type":null}},"conjugate":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.conjugate","name":"conjugate","setter_type":null,"type":"numpy.ma.core._MaskedUnaryOperation"}},"convolve":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","v","mode","propagate_mask"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.convolve","name":"convolve","original_first_arg":"a","type":null}},"copy":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.copy","name":"copy","setter_type":null,"type":"numpy.ma.core._frommethod"}},"correlate":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","v","mode","propagate_mask"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.correlate","name":"correlate","original_first_arg":"a","type":null}},"cos":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.cos","name":"cos","setter_type":null,"type":"numpy.ma.core._MaskedUnaryOperation"}},"cosh":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.cosh","name":"cosh","setter_type":null,"type":"numpy.ma.core._MaskedUnaryOperation"}},"count":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.ma.core.count","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["self","axis","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.count","name":"count","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","axis","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.count","name":"count","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","axis","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","axis","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.count","name":"count","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","axis","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.count","name":"count","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","axis","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3],"arg_names":["self","axis","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.count","name":"count","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,3],"arg_names":["self","axis","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.count","name":"count","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3],"arg_names":["self","axis","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","axis","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.count","name":"count","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","axis","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.count","name":"count","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","axis","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","axis","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","axis","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,3],"arg_names":["self","axis","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","axis","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"cumprod":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.cumprod","name":"cumprod","setter_type":null,"type":"numpy.ma.core._frommethod"}},"cumsum":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.cumsum","name":"cumsum","setter_type":null,"type":"numpy.ma.core._frommethod"}},"datetime64":{".class":"SymbolTableNode","cross_ref":"numpy.datetime64","kind":"Gdef","module_hidden":true,"module_public":false},"default_fill_value":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.default_fill_value","name":"default_fill_value","original_first_arg":"obj","type":null}},"diag":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["v","k"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.diag","name":"diag","original_first_arg":"v","type":null}},"diagonal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.diagonal","name":"diagonal","setter_type":null,"type":"numpy.ma.core._frommethod"}},"diff":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":[null,"n","axis","prepend","append"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.diff","name":"diff","original_first_arg":"a","type":null}},"divide":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.divide","name":"divide","setter_type":null,"type":"numpy.ma.core._DomainedBinaryOperation"}},"dot":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","b","strict","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.dot","name":"dot","original_first_arg":"a","type":null}},"dtype":{".class":"SymbolTableNode","cross_ref":"numpy.dtype","kind":"Gdef","module_hidden":true,"module_public":false},"dtypes":{".class":"SymbolTableNode","cross_ref":"numpy.dtypes","kind":"Gdef","module_hidden":true,"module_public":false},"empty":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.empty","name":"empty","setter_type":null,"type":"numpy.ma.core._convert2ma"}},"empty_like":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.empty_like","name":"empty_like","setter_type":null,"type":"numpy.ma.core._convert2ma"}},"equal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.equal","name":"equal","setter_type":null,"type":"numpy.ma.core._MaskedBinaryOperation"}},"exp":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.exp","name":"exp","setter_type":null,"type":"numpy.ma.core._MaskedUnaryOperation"}},"expand_dims":{".class":"SymbolTableNode","cross_ref":"numpy.lib._shape_base_impl.expand_dims","kind":"Gdef"},"fabs":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.fabs","name":"fabs","setter_type":null,"type":"numpy.ma.core._MaskedUnaryOperation"}},"filled":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.ma.core.filled","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","fill_value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.filled","name":"filled","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","fill_value"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":-1,"name":"_ShapeT_co","namespace":"numpy.ma.core.filled#0","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":-2,"name":"_DTypeT_co","namespace":"numpy.ma.core.filled#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ndarray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"filled","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":-1,"name":"_ShapeT_co","namespace":"numpy.ma.core.filled#0","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":-2,"name":"_DTypeT_co","namespace":"numpy.ma.core.filled#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":-1,"name":"_ShapeT_co","namespace":"numpy.ma.core.filled#0","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":-2,"name":"_DTypeT_co","namespace":"numpy.ma.core.filled#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.filled","name":"filled","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","fill_value"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":-1,"name":"_ShapeT_co","namespace":"numpy.ma.core.filled#0","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":-2,"name":"_DTypeT_co","namespace":"numpy.ma.core.filled#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ndarray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"filled","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":-1,"name":"_ShapeT_co","namespace":"numpy.ma.core.filled#0","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":-2,"name":"_DTypeT_co","namespace":"numpy.ma.core.filled#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":-1,"name":"_ShapeT_co","namespace":"numpy.ma.core.filled#0","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":-2,"name":"_DTypeT_co","namespace":"numpy.ma.core.filled#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","fill_value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.filled","name":"filled","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","fill_value"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"filled","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT_co","id":-1,"name":"_ScalarT_co","namespace":"numpy.ma.core.filled#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.filled","name":"filled","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","fill_value"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"filled","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT_co","id":-1,"name":"_ScalarT_co","namespace":"numpy.ma.core.filled#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","fill_value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.filled","name":"filled","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","fill_value"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"filled","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.filled","name":"filled","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","fill_value"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"filled","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","fill_value"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":-1,"name":"_ShapeT_co","namespace":"numpy.ma.core.filled#0","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":-2,"name":"_DTypeT_co","namespace":"numpy.ma.core.filled#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ndarray"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"filled","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":-1,"name":"_ShapeT_co","namespace":"numpy.ma.core.filled#0","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":-2,"name":"_DTypeT_co","namespace":"numpy.ma.core.filled#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":-1,"name":"_ShapeT_co","namespace":"numpy.ma.core.filled#0","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":-2,"name":"_DTypeT_co","namespace":"numpy.ma.core.filled#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","fill_value"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"filled","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT_co","id":-1,"name":"_ScalarT_co","namespace":"numpy.ma.core.filled#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":1}]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","fill_value"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"filled","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"fix_invalid":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["a","mask","copy","fill_value"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.fix_invalid","name":"fix_invalid","original_first_arg":"a","type":null}},"flatten_mask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["mask"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.flatten_mask","name":"flatten_mask","original_first_arg":"mask","type":null}},"flatten_structured_array":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.flatten_structured_array","name":"flatten_structured_array","original_first_arg":"a","type":null}},"float64":{".class":"SymbolTableNode","cross_ref":"numpy.float64","kind":"Gdef","module_hidden":true,"module_public":false},"floating":{".class":"SymbolTableNode","cross_ref":"numpy.floating","kind":"Gdef","module_hidden":true,"module_public":false},"floor":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.floor","name":"floor","setter_type":null,"type":"numpy.ma.core._MaskedUnaryOperation"}},"floor_divide":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.floor_divide","name":"floor_divide","setter_type":null,"type":"numpy.ma.core._DomainedBinaryOperation"}},"fmod":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.fmod","name":"fmod","setter_type":null,"type":"numpy.ma.core._DomainedBinaryOperation"}},"frombuffer":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.frombuffer","name":"frombuffer","setter_type":null,"type":"numpy.ma.core._convert2ma"}},"fromflex":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["fxarray"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.fromflex","name":"fromflex","original_first_arg":"fxarray","type":null}},"fromfunction":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.fromfunction","name":"fromfunction","setter_type":null,"type":"numpy.ma.core._convert2ma"}},"generic":{".class":"SymbolTableNode","cross_ref":"numpy.generic","kind":"Gdef","module_hidden":true,"module_public":false},"get_data":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.ma.core.get_data","name":"get_data","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","subok"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":true,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_mask":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.ma.core.get_mask","name":"get_mask","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":-1,"name":"_ShapeT_co","namespace":"numpy.ma.core.getmask#1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":-1,"name":"_ShapeT_co","namespace":"numpy.ma.core.getmask#1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"Instance","args":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":-1,"name":"_ShapeT_co","namespace":"numpy.ma.core.getmask#1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1}]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"getdata":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","subok"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.getdata","name":"getdata","original_first_arg":"a","type":null}},"getmask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.ma.core.getmask","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.getmask","name":"getmask","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getmask","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.getmask","name":"getmask","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getmask","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.getmask","name":"getmask","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":-1,"name":"_ShapeT_co","namespace":"numpy.ma.core.getmask#1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getmask","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":-1,"name":"_ShapeT_co","namespace":"numpy.ma.core.getmask#1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"Instance","args":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":-1,"name":"_ShapeT_co","namespace":"numpy.ma.core.getmask#1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.getmask","name":"getmask","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":-1,"name":"_ShapeT_co","namespace":"numpy.ma.core.getmask#1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getmask","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":-1,"name":"_ShapeT_co","namespace":"numpy.ma.core.getmask#1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"Instance","args":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":-1,"name":"_ShapeT_co","namespace":"numpy.ma.core.getmask#1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.getmask","name":"getmask","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getmask","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.getmask","name":"getmask","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getmask","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getmask","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":-1,"name":"_ShapeT_co","namespace":"numpy.ma.core.getmask#1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getmask","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":-1,"name":"_ShapeT_co","namespace":"numpy.ma.core.getmask#1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"Instance","args":[{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":-1,"name":"_ShapeT_co","namespace":"numpy.ma.core.getmask#1","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1}]},{".class":"CallableType","arg_kinds":[0],"arg_names":["a"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getmask","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"getmaskarray":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["arr"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.getmaskarray","name":"getmaskarray","original_first_arg":"arr","type":null}},"greater":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.greater","name":"greater","setter_type":null,"type":"numpy.ma.core._MaskedBinaryOperation"}},"greater_equal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.greater_equal","name":"greater_equal","setter_type":null,"type":"numpy.ma.core._MaskedBinaryOperation"}},"harden_mask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.harden_mask","name":"harden_mask","setter_type":null,"type":"numpy.ma.core._frommethod"}},"hypot":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.hypot","name":"hypot","setter_type":null,"type":"numpy.ma.core._MaskedBinaryOperation"}},"identity":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.identity","name":"identity","setter_type":null,"type":"numpy.ma.core._convert2ma"}},"ids":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.ids","name":"ids","setter_type":null,"type":"numpy.ma.core._frommethod"}},"indices":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.indices","name":"indices","setter_type":null,"type":"numpy.ma.core._convert2ma"}},"inner":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","b"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.inner","name":"inner","original_first_arg":"a","type":null}},"innerproduct":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.ma.core.innerproduct","name":"innerproduct","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","b"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":true,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"int_":{".class":"SymbolTableNode","cross_ref":"numpy.int_","kind":"Gdef","module_hidden":true,"module_public":false},"integer":{".class":"SymbolTableNode","cross_ref":"numpy.integer","kind":"Gdef","module_hidden":true,"module_public":false},"intp":{".class":"SymbolTableNode","cross_ref":"numpy.intp","kind":"Gdef","module_hidden":true,"module_public":false},"isMA":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.ma.core.isMA","name":"isMA","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":true,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isMaskedArray":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.isMaskedArray","name":"isMaskedArray","original_first_arg":"x","type":null}},"is_mask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["m"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.is_mask","name":"is_mask","original_first_arg":"m","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["m"],"arg_types":["builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_mask","ret_type":"builtins.bool","type_guard":null,"type_is":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"unpack_kwargs":false,"variables":[]}}},"is_masked":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.is_masked","name":"is_masked","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":["builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_masked","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"isarray":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.ma.core.isarray","name":"isarray","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":true,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"left_shift":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","n"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.left_shift","name":"left_shift","original_first_arg":"a","type":null}},"less":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.less","name":"less","setter_type":null,"type":"numpy.ma.core._MaskedBinaryOperation"}},"less_equal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.less_equal","name":"less_equal","setter_type":null,"type":"numpy.ma.core._MaskedBinaryOperation"}},"log":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.log","name":"log","setter_type":null,"type":"numpy.ma.core._MaskedUnaryOperation"}},"log10":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.log10","name":"log10","setter_type":null,"type":"numpy.ma.core._MaskedUnaryOperation"}},"log2":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.log2","name":"log2","setter_type":null,"type":"numpy.ma.core._MaskedUnaryOperation"}},"logical_and":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.logical_and","name":"logical_and","setter_type":null,"type":"numpy.ma.core._MaskedBinaryOperation"}},"logical_not":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.logical_not","name":"logical_not","setter_type":null,"type":"numpy.ma.core._MaskedUnaryOperation"}},"logical_or":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.logical_or","name":"logical_or","setter_type":null,"type":"numpy.ma.core._MaskedBinaryOperation"}},"logical_xor":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.logical_xor","name":"logical_xor","setter_type":null,"type":"numpy.ma.core._MaskedBinaryOperation"}},"make_mask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["m","copy","shrink","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.make_mask","name":"make_mask","original_first_arg":"m","type":null}},"make_mask_descr":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["ndtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.make_mask_descr","name":"make_mask_descr","original_first_arg":"ndtype","type":null}},"make_mask_none":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["newshape","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.make_mask_none","name":"make_mask_none","original_first_arg":"newshape","type":null}},"mask_or":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["m1","m2","copy","shrink"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.mask_or","name":"mask_or","original_first_arg":"m1","type":null}},"mask_rowcols":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.mask_rowcols","name":"mask_rowcols","original_first_arg":"a","type":null}},"masked":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.masked","name":"masked","setter_type":null,"type":"numpy.ma.core.MaskedConstant"}},"masked_array":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy.ma.core.masked_array","line":1080,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}}},"masked_equal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["x","value","copy"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.masked_equal","name":"masked_equal","original_first_arg":"x","type":null}},"masked_greater":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["x","value","copy"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.masked_greater","name":"masked_greater","original_first_arg":"x","type":null}},"masked_greater_equal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["x","value","copy"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.masked_greater_equal","name":"masked_greater_equal","original_first_arg":"x","type":null}},"masked_inside":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["x","v1","v2","copy"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.masked_inside","name":"masked_inside","original_first_arg":"x","type":null}},"masked_invalid":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","copy"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.masked_invalid","name":"masked_invalid","original_first_arg":"a","type":null}},"masked_less":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["x","value","copy"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.masked_less","name":"masked_less","original_first_arg":"x","type":null}},"masked_less_equal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["x","value","copy"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.masked_less_equal","name":"masked_less_equal","original_first_arg":"x","type":null}},"masked_not_equal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["x","value","copy"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.masked_not_equal","name":"masked_not_equal","original_first_arg":"x","type":null}},"masked_object":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["x","value","copy","shrink"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.masked_object","name":"masked_object","original_first_arg":"x","type":null}},"masked_outside":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["x","v1","v2","copy"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.masked_outside","name":"masked_outside","original_first_arg":"x","type":null}},"masked_print_option":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.masked_print_option","name":"masked_print_option","setter_type":null,"type":"numpy.ma.core._MaskedPrintOption"}},"masked_singleton":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.masked_singleton","name":"masked_singleton","setter_type":null,"type":"numpy.ma.core.MaskedConstant"}},"masked_values":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1],"arg_names":["x","value","rtol","atol","copy","shrink"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.masked_values","name":"masked_values","original_first_arg":"x","type":null}},"masked_where":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["condition","a","copy"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.masked_where","name":"masked_where","original_first_arg":"condition","type":null}},"max":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.ma.core.max","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["obj","axis","out","fill_value","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.max","name":"max","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["obj","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"max","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.max#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.max#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.max","name":"max","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["obj","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"max","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.max#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.max#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["obj","axis","out","fill_value","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.max","name":"max","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["obj","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"max","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.max","name":"max","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["obj","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"max","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1],"arg_names":["obj","axis","out","fill_value","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.max","name":"max","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1],"arg_names":["obj","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.max#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"max","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.max#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.max#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.max","name":"max","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1],"arg_names":["obj","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.max#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"max","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.max#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.max#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3,5,5],"arg_names":["obj","axis","out","fill_value","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.max","name":"max","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,1,3,5,5],"arg_names":["obj","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.max","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"max","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.max","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.max","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.max","name":"max","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3,5,5],"arg_names":["obj","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.max","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"max","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.max","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.max","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["obj","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"max","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.max#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.max#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["obj","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"max","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1],"arg_names":["obj","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.max#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"max","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.max#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.max#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5,5],"arg_names":["obj","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.max","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"max","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.max","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.max","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"maximum":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.maximum","name":"maximum","setter_type":null,"type":"numpy.ma.core._extrema_operation"}},"maximum_fill_value":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.maximum_fill_value","name":"maximum_fill_value","original_first_arg":"obj","type":null}},"mean":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.mean","name":"mean","setter_type":null,"type":"numpy.ma.core._frommethod"}},"min":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.ma.core.min","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["obj","axis","out","fill_value","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.min","name":"min","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["obj","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"min","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.min#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.min#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.min","name":"min","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["obj","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"min","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.min#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.min#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["obj","axis","out","fill_value","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.min","name":"min","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["obj","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"min","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.min","name":"min","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["obj","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"min","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1],"arg_names":["obj","axis","out","fill_value","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.min","name":"min","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1],"arg_names":["obj","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.min#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"min","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.min#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.min#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.min","name":"min","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1],"arg_names":["obj","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.min#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"min","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.min#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.min#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3,5,5],"arg_names":["obj","axis","out","fill_value","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.min","name":"min","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,1,3,5,5],"arg_names":["obj","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.min","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"min","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.min","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.min","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.min","name":"min","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3,5,5],"arg_names":["obj","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.min","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"min","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.min","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.min","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["obj","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"min","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.min#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.min#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["obj","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"min","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1],"arg_names":["obj","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.min#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"min","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.min#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.min#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5,5],"arg_names":["obj","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.min","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"min","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.min","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.min","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"minimum":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.minimum","name":"minimum","setter_type":null,"type":"numpy.ma.core._extrema_operation"}},"minimum_fill_value":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.minimum_fill_value","name":"minimum_fill_value","original_first_arg":"obj","type":null}},"mod":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.mod","name":"mod","setter_type":null,"type":"numpy.ma.core._DomainedBinaryOperation"}},"multiply":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.multiply","name":"multiply","setter_type":null,"type":"numpy.ma.core._MaskedBinaryOperation"}},"mvoid":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.mvoid","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.mvoid","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.ma.core.mvoid","name":"mvoid","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.mvoid","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.mvoid","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.ma.core.mvoid","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.ma.core","mro":["numpy.ma.core.mvoid","numpy.ma.core.MaskedArray","numpy.ndarray","numpy._ArrayOrScalarCommon","builtins.object"],"names":{".class":"SymbolTable","__getitem__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.mvoid.__getitem__","name":"__getitem__","original_first_arg":"self","type":null}},"__iter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.mvoid.__iter__","name":"__iter__","original_first_arg":"self","type":null}},"__len__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.mvoid.__len__","name":"__len__","original_first_arg":"self","type":null}},"__new__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,1],"arg_names":["self","data","mask","dtype","fill_value","hardmask","copy","subok"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static"],"fullname":"numpy.ma.core.mvoid.__new__","name":"__new__","original_first_arg":"self","type":null}},"__setitem__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":[null,null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.mvoid.__setitem__","name":"__setitem__","original_first_arg":"self","type":null}},"filled":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","fill_value"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.mvoid.filled","name":"filled","original_first_arg":"self","type":null}},"tolist":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.mvoid.tolist","name":"tolist","original_first_arg":"self","type":null}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core.mvoid.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"fullname":"numpy.ma.core._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.core.mvoid","upper_bound":{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"fullname":"numpy.ma.core._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.core.mvoid","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.mvoid"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_ShapeT_co","_DTypeT_co"],"typeddict_type":null}},"ndarray":{".class":"SymbolTableNode","cross_ref":"numpy.ndarray","kind":"Gdef","module_hidden":true,"module_public":false},"ndim":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.ndim","name":"ndim","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ndim","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"negative":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.negative","name":"negative","setter_type":null,"type":"numpy.ma.core._MaskedUnaryOperation"}},"nomask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.nomask","name":"nomask","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.bool","value":false}],"extra_attrs":null,"type_ref":"numpy.bool"}}},"nonzero":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.nonzero","name":"nonzero","setter_type":null,"type":"numpy.ma.core._frommethod"}},"not_equal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.not_equal","name":"not_equal","setter_type":null,"type":"numpy.ma.core._MaskedBinaryOperation"}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"object_":{".class":"SymbolTableNode","cross_ref":"numpy.object_","kind":"Gdef","module_hidden":true,"module_public":false},"ones":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.ones","name":"ones","setter_type":null,"type":"numpy.ma.core._convert2ma"}},"ones_like":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.ones_like","name":"ones_like","setter_type":null,"type":"numpy.ma.core._convert2ma"}},"outer":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","b"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.outer","name":"outer","original_first_arg":"a","type":null}},"outerproduct":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.ma.core.outerproduct","name":"outerproduct","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","b"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":true,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false},"power":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","b","third"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.power","name":"power","original_first_arg":"a","type":null}},"prod":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.prod","name":"prod","setter_type":null,"type":"numpy.ma.core._frommethod"}},"product":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.product","name":"product","setter_type":null,"type":"numpy.ma.core._frommethod"}},"ptp":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.ma.core.ptp","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["obj","axis","out","fill_value","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.ptp","name":"ptp","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["obj","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ptp","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.ptp#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.ptp#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.ptp","name":"ptp","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["obj","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ptp","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.ptp#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.ptp#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["obj","axis","out","fill_value","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.ptp","name":"ptp","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["obj","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ptp","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.ptp","name":"ptp","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["obj","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ptp","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1],"arg_names":["obj","axis","out","fill_value","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.ptp","name":"ptp","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1],"arg_names":["obj","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.ptp#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ptp","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.ptp#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.ptp#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.ptp","name":"ptp","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1],"arg_names":["obj","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.ptp#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ptp","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.ptp#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.ptp#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3,5,5],"arg_names":["obj","axis","out","fill_value","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.ptp","name":"ptp","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,1,3,5,5],"arg_names":["obj","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.ptp","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ptp","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.ptp","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.ptp","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.ptp","name":"ptp","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3,5,5],"arg_names":["obj","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.ptp","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ptp","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.ptp","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.ptp","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["obj","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},"numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ptp","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.ptp#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.ptp#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["obj","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ptp","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,1],"arg_names":["obj","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.ptp#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ptp","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.ptp#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.ptp#2","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5,5],"arg_names":["obj","axis","out","fill_value","keepdims"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.ptp","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","numpy._globals._NoValueType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ptp","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.ptp","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.ptp","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"put":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["a","indices","values","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.put","name":"put","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["a","indices","values","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"put","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"putmask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["a","mask","values"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.putmask","name":"putmask","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["a","mask","values"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"putmask","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"ravel":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.ravel","name":"ravel","setter_type":null,"type":"numpy.ma.core._frommethod"}},"remainder":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.remainder","name":"remainder","setter_type":null,"type":"numpy.ma.core._DomainedBinaryOperation"}},"repeat":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.repeat","name":"repeat","setter_type":null,"type":"numpy.ma.core._frommethod"}},"reshape":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["a","new_shape","order"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.reshape","name":"reshape","original_first_arg":"a","type":null}},"resize":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x","new_shape"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.resize","name":"resize","original_first_arg":"x","type":null}},"right_shift":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","n"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.right_shift","name":"right_shift","original_first_arg":"a","type":null}},"round":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.ma.core.round","name":"round","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["a","decimals","out"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":true,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"round_":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["a","decimals","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.round_","name":"round_","original_first_arg":"a","type":null}},"set_fill_value":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","fill_value"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.set_fill_value","name":"set_fill_value","original_first_arg":"a","type":null}},"shape":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.shape","name":"shape","original_first_arg":"obj","type":null}},"sin":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.sin","name":"sin","setter_type":null,"type":"numpy.ma.core._MaskedUnaryOperation"}},"sinh":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.sinh","name":"sinh","setter_type":null,"type":"numpy.ma.core._MaskedUnaryOperation"}},"size":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["obj","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.size","name":"size","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["obj","axis"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"size","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"soften_mask":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.soften_mask","name":"soften_mask","setter_type":null,"type":"numpy.ma.core._frommethod"}},"sometrue":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["target","axis","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.sometrue","name":"sometrue","original_first_arg":"target","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["target","axis","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sometrue","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"sort":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.ma.core.sort","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,5],"arg_names":["a","axis","kind","order","endwith","fill_value","stable"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.sort","name":"sort","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,5],"arg_names":["a","axis","kind","order","endwith","fill_value","stable"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.sort#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sort","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.sort#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.sort#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.sort","name":"sort","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,5],"arg_names":["a","axis","kind","order","endwith","fill_value","stable"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.sort#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sort","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.sort#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.sort#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,5],"arg_names":["a","axis","kind","order","endwith","fill_value","stable"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.sort","name":"sort","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,5],"arg_names":["a","axis","kind","order","endwith","fill_value","stable"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sort","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.sort","name":"sort","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,5],"arg_names":["a","axis","kind","order","endwith","fill_value","stable"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sort","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,5],"arg_names":["a","axis","kind","order","endwith","fill_value","stable"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.sort#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sort","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.sort#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.sort#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,5],"arg_names":["a","axis","kind","order","endwith","fill_value","stable"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sort","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"sqrt":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.sqrt","name":"sqrt","setter_type":null,"type":"numpy.ma.core._MaskedUnaryOperation"}},"squeeze":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.squeeze","name":"squeeze","setter_type":null,"type":"numpy.ma.core._convert2ma"}},"std":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.std","name":"std","setter_type":null,"type":"numpy.ma.core._frommethod"}},"str_":{".class":"SymbolTableNode","cross_ref":"numpy.str_","kind":"Gdef","module_hidden":true,"module_public":false},"subtract":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.subtract","name":"subtract","setter_type":null,"type":"numpy.ma.core._MaskedBinaryOperation"}},"sum":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.sum","name":"sum","setter_type":null,"type":"numpy.ma.core._frommethod"}},"swapaxes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.swapaxes","name":"swapaxes","setter_type":null,"type":"numpy.ma.core._frommethod"}},"take":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.ma.core.take","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["a","indices","axis","out","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.take","name":"take","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.take#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.take#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.take","name":"take","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.take#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.take#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["a","indices","axis","out","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.take","name":"take","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.take#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.take","name":"take","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.take#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["a","indices","axis","out","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.take","name":"take","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.take","name":"take","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["a","indices","axis","out","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.take","name":"take","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.take","name":"take","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1],"arg_names":["a","indices","axis","out","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.take","name":"take","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["a","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.take#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.take#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.take#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.take","name":"take","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["a","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.take#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.take#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.take#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,3,5],"arg_names":["a","indices","axis","out","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.ma.core.take","name":"take","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,3,5],"arg_names":["a","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.take","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.take","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.take","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.ma.core.take","name":"take","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,3,5],"arg_names":["a","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.take","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.take","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.take","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.take#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.take#0","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.ma.core.take#1","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.generic"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["a","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take","ret_type":{".class":"AnyType","missing_import_name":"numpy.ma.core.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["a","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.take#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.take#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.take#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,3,5],"arg_names":["a","indices","axis","out","mode"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.take","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"take","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.take","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.core._ArrayT","id":-1,"name":"_ArrayT","namespace":"numpy.ma.core.take","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"values":[],"variance":0}]}]}}},"tan":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.tan","name":"tan","setter_type":null,"type":"numpy.ma.core._MaskedUnaryOperation"}},"tanh":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.tanh","name":"tanh","setter_type":null,"type":"numpy.ma.core._MaskedUnaryOperation"}},"timedelta64":{".class":"SymbolTableNode","cross_ref":"numpy.timedelta64","kind":"Gdef","module_hidden":true,"module_public":false},"trace":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.trace","name":"trace","setter_type":null,"type":"numpy.ma.core._frommethod"}},"transpose":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","axes"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.transpose","name":"transpose","original_first_arg":"a","type":null}},"true_divide":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.true_divide","name":"true_divide","setter_type":null,"type":"numpy.ma.core._DomainedBinaryOperation"}},"var":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.var","name":"var","setter_type":null,"type":"numpy.ma.core._frommethod"}},"where":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["condition","x","y"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.core.where","name":"where","original_first_arg":"condition","type":null}},"zeros":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.zeros","name":"zeros","setter_type":null,"type":"numpy.ma.core._convert2ma"}},"zeros_like":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.core.zeros_like","name":"zeros_like","setter_type":null,"type":"numpy.ma.core._convert2ma"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/ma/core.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/ma/core.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/ma/core.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..6bbf4865a581f1331139145aebf638f7d2c1af81 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/ma/core.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[4,11,38,39,5,7,8,10,1,1,1],"dep_prios":[5,10,5,5,5,5,5,5,5,30,30],"dependencies":["collections.abc","numpy.dtypes","numpy._globals","numpy._typing","typing","_typeshed","typing_extensions","numpy","builtins","_frozen_importlib","abc"],"hash":"a255608167e674fd770b42e7ea367b770706b5e2","id":"numpy.ma.core","ignore_all":true,"interface_hash":"e7620100b5ec92e5331898ec1ae5b4fec23dfc2e","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/ma/core.pyi","plugin_data":null,"size":40459,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/ma/extras.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/ma/extras.data.json new file mode 100644 index 0000000000000000000000000000000000000000..b0a97c54f045b9fba955ed86dce39cbcab0d7a94 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/ma/extras.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.ma.extras","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","AxisConcatenator":{".class":"SymbolTableNode","cross_ref":"numpy.lib._index_tricks_impl.AxisConcatenator","kind":"Gdef","module_hidden":true,"module_public":false},"Incomplete":{".class":"SymbolTableNode","cross_ref":"_typeshed.Incomplete","kind":"Gdef","module_hidden":true,"module_public":false},"MAxisConcatenator":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.int","value":0},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.int","value":1},{".class":"LiteralType","fallback":"builtins.int","value":-1}],"extra_attrs":null,"type_ref":"numpy.lib._index_tricks_impl.AxisConcatenator"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.ma.extras.MAxisConcatenator","name":"MAxisConcatenator","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.ma.extras.MAxisConcatenator","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.ma.extras","mro":["numpy.ma.extras.MAxisConcatenator","numpy.lib._index_tricks_impl.AxisConcatenator","builtins.object"],"names":{".class":"SymbolTable","__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"numpy.ma.extras.MAxisConcatenator.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"concatenate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["arrays","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"numpy.ma.extras.MAxisConcatenator.concatenate","name":"concatenate","original_first_arg":"arrays","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["arrays","axis"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"concatenate of MAxisConcatenator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_staticmethod","is_ready","is_inferred"],"fullname":"numpy.ma.extras.MAxisConcatenator.concatenate","name":"concatenate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["arrays","axis"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"concatenate of MAxisConcatenator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"makemat":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","arr"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"numpy.ma.extras.MAxisConcatenator.makemat","name":"makemat","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","arr"],"arg_types":[{".class":"TypeType","item":"numpy.ma.extras.MAxisConcatenator"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"makemat of MAxisConcatenator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"numpy.ma.extras.MAxisConcatenator.makemat","name":"makemat","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","arr"],"arg_types":[{".class":"TypeType","item":"numpy.ma.extras.MAxisConcatenator"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"makemat of MAxisConcatenator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.extras.MAxisConcatenator.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.ma.extras.MAxisConcatenator","values":[],"variance":0},"slots":["axis","matrix","ndmin","trans1d"],"tuple_type":null,"type_vars":[],"typeddict_type":null}},"MaskedArray":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.MaskedArray","kind":"Gdef","module_hidden":true,"module_public":false},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.ma.extras.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.extras.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.extras.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.extras.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.extras.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.extras.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.extras.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_fromnxfunction":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.ma.extras._fromnxfunction","name":"_fromnxfunction","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.ma.extras._fromnxfunction","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.ma.extras","mro":["numpy.ma.extras._fromnxfunction","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":["self","args","params"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras._fromnxfunction.__call__","name":"__call__","original_first_arg":"self","type":null}},"__doc__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.extras._fromnxfunction.__doc__","name":"__doc__","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","funcname"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.ma.extras._fromnxfunction.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","funcname"],"arg_types":["numpy.ma.extras._fromnxfunction",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of _fromnxfunction","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__name__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.extras._fromnxfunction.__name__","name":"__name__","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}}},"getdoc":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras._fromnxfunction.getdoc","name":"getdoc","original_first_arg":"self","type":null}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.extras._fromnxfunction.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.ma.extras._fromnxfunction","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_fromnxfunction_allargs":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy.ma.extras._fromnxfunction"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.ma.extras._fromnxfunction_allargs","name":"_fromnxfunction_allargs","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.ma.extras._fromnxfunction_allargs","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.ma.extras","mro":["numpy.ma.extras._fromnxfunction_allargs","numpy.ma.extras._fromnxfunction","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":["self","args","params"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras._fromnxfunction_allargs.__call__","name":"__call__","original_first_arg":"self","type":null}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.extras._fromnxfunction_allargs.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.ma.extras._fromnxfunction_allargs","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_fromnxfunction_seq":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy.ma.extras._fromnxfunction"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.ma.extras._fromnxfunction_seq","name":"_fromnxfunction_seq","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.ma.extras._fromnxfunction_seq","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.ma.extras","mro":["numpy.ma.extras._fromnxfunction_seq","numpy.ma.extras._fromnxfunction","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,2,4],"arg_names":["self","x","args","params"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras._fromnxfunction_seq.__call__","name":"__call__","original_first_arg":"self","type":null}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.extras._fromnxfunction_seq.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.ma.extras._fromnxfunction_seq","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_fromnxfunction_single":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy.ma.extras._fromnxfunction"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.ma.extras._fromnxfunction_single","name":"_fromnxfunction_single","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.ma.extras._fromnxfunction_single","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.ma.extras","mro":["numpy.ma.extras._fromnxfunction_single","numpy.ma.extras._fromnxfunction","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,2,4],"arg_names":["self","x","args","params"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras._fromnxfunction_single.__call__","name":"__call__","original_first_arg":"self","type":null}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.extras._fromnxfunction_single.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.ma.extras._fromnxfunction_single","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"apply_along_axis":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,2,4],"arg_names":["func1d","axis","arr","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras.apply_along_axis","name":"apply_along_axis","original_first_arg":"func1d","type":null}},"apply_over_axes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["func","a","axes"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras.apply_over_axes","name":"apply_over_axes","original_first_arg":"func","type":null}},"atleast_1d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.extras.atleast_1d","name":"atleast_1d","setter_type":null,"type":"numpy.ma.extras._fromnxfunction_allargs"}},"atleast_2d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.extras.atleast_2d","name":"atleast_2d","setter_type":null,"type":"numpy.ma.extras._fromnxfunction_allargs"}},"atleast_3d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.extras.atleast_3d","name":"atleast_3d","setter_type":null,"type":"numpy.ma.extras._fromnxfunction_allargs"}},"average":{".class":"SymbolTableNode","cross_ref":"numpy.lib._function_base_impl.average","kind":"Gdef"},"clump_masked":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras.clump_masked","name":"clump_masked","original_first_arg":"a","type":null}},"clump_unmasked":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras.clump_unmasked","name":"clump_unmasked","original_first_arg":"a","type":null}},"column_stack":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.extras.column_stack","name":"column_stack","setter_type":null,"type":"numpy.ma.extras._fromnxfunction_seq"}},"compress_cols":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras.compress_cols","name":"compress_cols","original_first_arg":"a","type":null}},"compress_nd":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["x","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras.compress_nd","name":"compress_nd","original_first_arg":"x","type":null}},"compress_rowcols":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["x","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras.compress_rowcols","name":"compress_rowcols","original_first_arg":"x","type":null}},"compress_rows":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras.compress_rows","name":"compress_rows","original_first_arg":"a","type":null}},"corrcoef":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1],"arg_names":["x","y","rowvar","bias","allow_masked","ddof"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras.corrcoef","name":"corrcoef","original_first_arg":"x","type":null}},"count_masked":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["arr","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras.count_masked","name":"count_masked","original_first_arg":"arr","type":null}},"cov":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1],"arg_names":["x","y","rowvar","bias","allow_masked","ddof"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras.cov","name":"cov","original_first_arg":"x","type":null}},"diagflat":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.extras.diagflat","name":"diagflat","setter_type":null,"type":"numpy.ma.extras._fromnxfunction_single"}},"dot":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.dot","kind":"Gdef"},"dstack":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.extras.dstack","name":"dstack","setter_type":null,"type":"numpy.ma.extras._fromnxfunction_seq"}},"ediff1d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["arr","to_end","to_begin"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras.ediff1d","name":"ediff1d","original_first_arg":"arr","type":null}},"flatnotmasked_contiguous":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras.flatnotmasked_contiguous","name":"flatnotmasked_contiguous","original_first_arg":"a","type":null}},"flatnotmasked_edges":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["a"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras.flatnotmasked_edges","name":"flatnotmasked_edges","original_first_arg":"a","type":null}},"hsplit":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.extras.hsplit","name":"hsplit","setter_type":null,"type":"numpy.ma.extras._fromnxfunction_single"}},"hstack":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.extras.hstack","name":"hstack","setter_type":null,"type":"numpy.ma.extras._fromnxfunction_seq"}},"in1d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["ar1","ar2","assume_unique","invert"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras.in1d","name":"in1d","original_first_arg":"ar1","type":null}},"intersect1d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["ar1","ar2","assume_unique"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras.intersect1d","name":"intersect1d","original_first_arg":"ar1","type":null}},"isin":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["element","test_elements","assume_unique","invert"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras.isin","name":"isin","original_first_arg":"element","type":null}},"mask_cols":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras.mask_cols","name":"mask_cols","original_first_arg":"a","type":null}},"mask_rowcols":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras.mask_rowcols","name":"mask_rowcols","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","axis"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mask_rowcols","ret_type":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"mask_rows":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras.mask_rows","name":"mask_rows","original_first_arg":"a","type":null}},"masked_all":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["shape","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras.masked_all","name":"masked_all","original_first_arg":"shape","type":null}},"masked_all_like":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["arr"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras.masked_all_like","name":"masked_all_like","original_first_arg":"arr","type":null}},"median":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["a","axis","out","overwrite_input","keepdims"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras.median","name":"median","original_first_arg":"a","type":null}},"mr_":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.extras.mr_","name":"mr_","setter_type":null,"type":"numpy.ma.extras.mr_class"}},"mr_class":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy.ma.extras.MAxisConcatenator"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.ma.extras.mr_class","name":"mr_class","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.ma.extras.mr_class","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.ma.extras","mro":["numpy.ma.extras.mr_class","numpy.ma.extras.MAxisConcatenator","numpy.lib._index_tricks_impl.AxisConcatenator","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.ma.extras.mr_class.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.ma.extras.mr_class"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of mr_class","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"numpy.ma.extras.mr_class.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.extras.mr_class.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.ma.extras.mr_class","values":[],"variance":0},"slots":["axis","matrix","ndmin","trans1d"],"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ndenumerate":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","compressed"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras.ndenumerate","name":"ndenumerate","original_first_arg":"a","type":null}},"notmasked_contiguous":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras.notmasked_contiguous","name":"notmasked_contiguous","original_first_arg":"a","type":null}},"notmasked_edges":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["a","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras.notmasked_edges","name":"notmasked_edges","original_first_arg":"a","type":null}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"polyfit":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1,1],"arg_names":["x","y","deg","rcond","full","w","cov"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras.polyfit","name":"polyfit","original_first_arg":"x","type":null}},"row_stack":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.extras.row_stack","name":"row_stack","setter_type":null,"type":"numpy.ma.extras._fromnxfunction_seq"}},"setdiff1d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["ar1","ar2","assume_unique"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras.setdiff1d","name":"setdiff1d","original_first_arg":"ar1","type":null}},"setxor1d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["ar1","ar2","assume_unique"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras.setxor1d","name":"setxor1d","original_first_arg":"ar1","type":null}},"stack":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.extras.stack","name":"stack","setter_type":null,"type":"numpy.ma.extras._fromnxfunction_seq"}},"union1d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["ar1","ar2"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras.union1d","name":"union1d","original_first_arg":"ar1","type":null}},"unique":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["ar1","return_index","return_inverse"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras.unique","name":"unique","original_first_arg":"ar1","type":null}},"vander":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["x","n"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.extras.vander","name":"vander","original_first_arg":"x","type":null}},"vstack":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.extras.vstack","name":"vstack","setter_type":null,"type":"numpy.ma.extras._fromnxfunction_seq"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/ma/extras.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/ma/extras.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/ma/extras.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..cacd0cd24ad230c8aa7f4b5b205bfeb990112c11 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/ma/extras.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[4,5,7,1,3,1,1,1,1,1],"dep_prios":[5,5,5,5,10,5,30,30,30,30],"dependencies":["numpy.lib._function_base_impl","numpy.lib._index_tricks_impl","numpy.ma.core","_typeshed","numpy","builtins","_frozen_importlib","abc","numpy.lib","typing"],"hash":"971116689be7e479514ee532f394cab9bdd7f9b4","id":"numpy.ma.extras","ignore_all":true,"interface_hash":"64d872252c529c23ad90234f16a5f4129f54cde4","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/ma/extras.pyi","plugin_data":null,"size":3834,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/ma/mrecords.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/ma/mrecords.data.json new file mode 100644 index 0000000000000000000000000000000000000000..5c3eb8ff804695ef703dbc21e77882172789f0f7 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/ma/mrecords.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.ma.mrecords","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"MaskedArray":{".class":"SymbolTableNode","cross_ref":"numpy.ma.core.MaskedArray","kind":"Gdef","module_hidden":true,"module_public":false},"MaskedRecords":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.mrecords._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.mrecords.MaskedRecords","upper_bound":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.mrecords._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.mrecords.MaskedRecords","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.core.MaskedArray"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.ma.mrecords.MaskedRecords","name":"MaskedRecords","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.mrecords._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.mrecords.MaskedRecords","upper_bound":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.mrecords._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.mrecords.MaskedRecords","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.ma.mrecords.MaskedRecords","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.ma.mrecords","mro":["numpy.ma.mrecords.MaskedRecords","numpy.ma.core.MaskedArray","numpy.ndarray","numpy._ArrayOrScalarCommon","builtins.object"],"names":{".class":"SymbolTable","__array_finalize__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.mrecords.MaskedRecords.__array_finalize__","name":"__array_finalize__","original_first_arg":"self","type":null}},"__getattribute__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.mrecords.MaskedRecords.__getattribute__","name":"__getattribute__","original_first_arg":"self","type":null}},"__getitem__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.mrecords.MaskedRecords.__getitem__","name":"__getitem__","original_first_arg":"self","type":null}},"__len__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.mrecords.MaskedRecords.__len__","name":"__len__","original_first_arg":"self","type":null}},"__new__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4],"arg_names":["cls","shape","dtype","buf","offset","strides","formats","names","titles","byteorder","aligned","mask","hard_mask","fill_value","keep_mask","copy","options"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static"],"fullname":"numpy.ma.mrecords.MaskedRecords.__new__","name":"__new__","original_first_arg":"cls","type":null}},"__reduce__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.mrecords.MaskedRecords.__reduce__","name":"__reduce__","original_first_arg":"self","type":null}},"__setattr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","attr","val"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.mrecords.MaskedRecords.__setattr__","name":"__setattr__","original_first_arg":"self","type":null}},"__setitem__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":[null,null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.mrecords.MaskedRecords.__setitem__","name":"__setitem__","original_first_arg":"self","type":null}},"_data":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated"],"fullname":"numpy.ma.mrecords.MaskedRecords._data","name":"_data","original_first_arg":"self","type":null},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy.ma.mrecords.MaskedRecords._data","name":"_data","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.mrecords._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.mrecords.MaskedRecords","upper_bound":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.mrecords._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.mrecords.MaskedRecords","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.mrecords.MaskedRecords"}],"fallback":"builtins.function","from_concatenate":false,"implicit":true,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_data of MaskedRecords","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"_fieldmask":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated"],"fullname":"numpy.ma.mrecords.MaskedRecords._fieldmask","name":"_fieldmask","original_first_arg":"self","type":null},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy.ma.mrecords.MaskedRecords._fieldmask","name":"_fieldmask","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.mrecords._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.mrecords.MaskedRecords","upper_bound":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.mrecords._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.mrecords.MaskedRecords","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.mrecords.MaskedRecords"}],"fallback":"builtins.function","from_concatenate":false,"implicit":true,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_fieldmask of MaskedRecords","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"_fill_value":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.mrecords.MaskedRecords._fill_value","name":"_fill_value","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"_mask":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.ma.mrecords.MaskedRecords._mask","name":"_mask","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"copy":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.mrecords.MaskedRecords.copy","name":"copy","original_first_arg":"self","type":null}},"harden_mask":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.mrecords.MaskedRecords.harden_mask","name":"harden_mask","original_first_arg":"self","type":null}},"soften_mask":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.mrecords.MaskedRecords.soften_mask","name":"soften_mask","original_first_arg":"self","type":null}},"tolist":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","fill_value"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.mrecords.MaskedRecords.tolist","name":"tolist","original_first_arg":"self","type":null}},"view":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["self","dtype","type"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.mrecords.MaskedRecords.view","name":"view","original_first_arg":"self","type":null}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.mrecords.MaskedRecords.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.mrecords._ShapeT_co","id":1,"name":"_ShapeT_co","namespace":"numpy.ma.mrecords.MaskedRecords","upper_bound":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},"values":[],"variance":1},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.mrecords._DTypeT_co","id":2,"name":"_DTypeT_co","namespace":"numpy.ma.mrecords.MaskedRecords","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.ma.mrecords.MaskedRecords"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_ShapeT_co","_DTypeT_co"],"typeddict_type":null}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"_DTypeT_co":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.mrecords._DTypeT_co","name":"_DTypeT_co","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"},"values":[],"variance":1}},"_ShapeT_co":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.ma.mrecords._ShapeT_co","name":"_ShapeT_co","upper_bound":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"},"values":[],"variance":1}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.ma.mrecords.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.mrecords.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.mrecords.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.mrecords.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.mrecords.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.mrecords.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.ma.mrecords.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"addfield":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["mrecord","newfield","newfieldname"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.mrecords.addfield","name":"addfield","original_first_arg":"mrecord","type":null}},"dtype":{".class":"SymbolTableNode","cross_ref":"numpy.dtype","kind":"Gdef","module_hidden":true,"module_public":false},"fromarrays":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1,1,1],"arg_names":["arraylist","dtype","shape","formats","names","titles","aligned","byteorder","fill_value"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.mrecords.fromarrays","name":"fromarrays","original_first_arg":"arraylist","type":null}},"fromrecords":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1,1,1,1],"arg_names":["reclist","dtype","shape","formats","names","titles","aligned","byteorder","fill_value","mask"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.mrecords.fromrecords","name":"fromrecords","original_first_arg":"reclist","type":null}},"fromtextfile":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1],"arg_names":["fname","delimiter","commentchar","missingchar","varnames","vartypes"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.ma.mrecords.fromtextfile","name":"fromtextfile","original_first_arg":"fname","type":null}},"mrecarray":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"numpy.ma.mrecords.mrecarray","line":58,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"numpy.ma.mrecords.MaskedRecords"}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/ma/mrecords.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/ma/mrecords.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/ma/mrecords.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..940742fd6a93be8328be12a48ec6fa827f0cc8ce --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/ma/mrecords.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[5,1,3,1,1,1,1],"dep_prios":[5,5,5,5,30,30,30],"dependencies":["numpy.ma","typing","numpy","builtins","_frozen_importlib","abc","numpy.ma.core"],"hash":"3bd0a210d72e1db502f5ced3b85c0ebead323766","id":"numpy.ma.mrecords","ignore_all":true,"interface_hash":"b4ed066036515d75d6bed359bcd8a3fdcce9af1d","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/ma/mrecords.pyi","plugin_data":null,"size":1973,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/matrixlib/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/matrixlib/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..f8b5b1864e8b4d55e277d52272069514ecc2cecc --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/matrixlib/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.matrixlib","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.matrixlib.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.matrixlib.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.matrixlib.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.matrixlib.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.matrixlib.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.matrixlib.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.matrixlib.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.matrixlib.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"asmatrix":{".class":"SymbolTableNode","cross_ref":"numpy.matrixlib.defmatrix.asmatrix","kind":"Gdef"},"bmat":{".class":"SymbolTableNode","cross_ref":"numpy.matrixlib.defmatrix.bmat","kind":"Gdef"},"matrix":{".class":"SymbolTableNode","cross_ref":"numpy.matrix","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/matrixlib/__init__.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/matrixlib/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/matrixlib/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..f0be7a6aea2697988640dcf43a8f6a7b7cc077bb --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/matrixlib/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[3,1,1,1,1,1],"dep_prios":[5,5,5,30,30,30],"dependencies":["numpy.matrixlib.defmatrix","numpy","builtins","_frozen_importlib","abc","typing"],"hash":"fe3b707bb8dbad25d53344df1c3288f5e498f642","id":"numpy.matrixlib","ignore_all":true,"interface_hash":"a99c679e97bb26313e1256b980b4f18ce7aa1b82","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/matrixlib/__init__.pyi","plugin_data":null,"size":106,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/matrixlib/defmatrix.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/matrixlib/defmatrix.data.json new file mode 100644 index 0000000000000000000000000000000000000000..498f3505fb1b8e4e804ec298a4cc51983483e323 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/matrixlib/defmatrix.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.matrixlib.defmatrix","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"DTypeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like.DTypeLike","kind":"Gdef","module_hidden":true,"module_public":false},"Mapping":{".class":"SymbolTableNode","cross_ref":"typing.Mapping","kind":"Gdef","module_hidden":true,"module_public":false},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef","module_hidden":true,"module_public":false},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.matrixlib.defmatrix.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.matrixlib.defmatrix.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.matrixlib.defmatrix.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.matrixlib.defmatrix.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.matrixlib.defmatrix.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.matrixlib.defmatrix.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.matrixlib.defmatrix.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"asmatrix":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["data","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.matrixlib.defmatrix.asmatrix","name":"asmatrix","original_first_arg":"data","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["data","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"asmatrix","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.matrix"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"bmat":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["obj","ldict","gdict"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.matrixlib.defmatrix.bmat","name":"bmat","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["obj","ldict","gdict"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"bmat","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.matrix"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"matrix":{".class":"SymbolTableNode","cross_ref":"numpy.matrix","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/matrixlib/defmatrix.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/matrixlib/defmatrix.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/matrixlib/defmatrix.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..5352e451d4208ff090802a1608691d59b1e85c94 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/matrixlib/defmatrix.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,5,2,4,1,1,1],"dep_prios":[5,5,5,5,5,30,30],"dependencies":["collections.abc","numpy._typing","typing","numpy","builtins","_frozen_importlib","abc"],"hash":"33460d8717f6083c0cbe03a4b439375f62822658","id":"numpy.matrixlib.defmatrix","ignore_all":true,"interface_hash":"bf4007a59cfe7667b4aa71d3747362d04b36f400","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/matrixlib/defmatrix.pyi","plugin_data":null,"size":478,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..dfd8b64f0fdcb3bdd54cf0980985b0dda1b23c36 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.polynomial","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Chebyshev":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial.chebyshev.Chebyshev","kind":"Gdef"},"Final":{".class":"SymbolTableNode","cross_ref":"typing.Final","kind":"Gdef","module_hidden":true,"module_public":false},"Hermite":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial.hermite.Hermite","kind":"Gdef"},"HermiteE":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial.hermite_e.HermiteE","kind":"Gdef"},"Laguerre":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial.laguerre.Laguerre","kind":"Gdef"},"Legendre":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial.legendre.Legendre","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"Polynomial":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial.polynomial.Polynomial","kind":"Gdef"},"_PytestTester":{".class":"SymbolTableNode","cross_ref":"numpy._pytesttester.PytestTester","kind":"Gdef","module_hidden":true,"module_public":false},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.polynomial.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"chebyshev":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial.chebyshev","kind":"Gdef"},"hermite":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial.hermite","kind":"Gdef"},"hermite_e":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial.hermite_e","kind":"Gdef"},"laguerre":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial.laguerre","kind":"Gdef"},"legendre":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial.legendre","kind":"Gdef"},"polynomial":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial.polynomial","kind":"Gdef"},"set_default_printstyle":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["style"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.polynomial.set_default_printstyle","name":"set_default_printstyle","original_first_arg":"style","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["style"],"arg_types":[{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"ascii"},{".class":"LiteralType","fallback":"builtins.str","value":"unicode"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"set_default_printstyle","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"test":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy.polynomial.test","name":"test","setter_type":null,"type":"numpy._pytesttester.PytestTester"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/polynomial/__init__.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..957f08ec7b39fd5f96bcbdc30f65855face8b2be --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[3,3,3,3,3,3,23,1,1,1,1],"dep_prios":[5,5,5,5,5,5,5,5,5,30,30],"dependencies":["numpy.polynomial.chebyshev","numpy.polynomial.hermite","numpy.polynomial.hermite_e","numpy.polynomial.laguerre","numpy.polynomial.legendre","numpy.polynomial.polynomial","numpy._pytesttester","typing","builtins","_frozen_importlib","abc"],"hash":"c0dec09c2cce81cd87569f6ac5ecf60bee4dcf69","id":"numpy.polynomial","ignore_all":true,"interface_hash":"cf64c2c94c19dfd2a2d13d7168ea95b9e86d5584","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/polynomial/__init__.pyi","plugin_data":null,"size":688,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/_polybase.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/_polybase.data.json new file mode 100644 index 0000000000000000000000000000000000000000..4a817398de15113f500bb85f9ab16afa6607e3bf --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/_polybase.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.polynomial._polybase","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","ABCPolyBase":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["abc.ABC"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.polynomial._polybase.ABCPolyBase","name":"ABCPolyBase","type_vars":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.polynomial._polybase.ABCPolyBase","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.polynomial._polybase","mro":["numpy.polynomial._polybase.ABCPolyBase","abc.ABC","builtins.object"],"names":{".class":"SymbolTable","__add__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__add__","name":"__add__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__add__ of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__array_ufunc__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__array_ufunc__","name":"__array_ufunc__","setter_type":null,"type":{".class":"NoneType"}}},"__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__call__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"arg"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"arg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polybase._Other","id":-1,"name":"_Other","namespace":"numpy.polynomial._polybase.ABCPolyBase.__call__#0","upper_bound":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of ABCPolyBase","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polybase._Other","id":-1,"name":"_Other","namespace":"numpy.polynomial._polybase.ABCPolyBase.__call__#0","upper_bound":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polybase._Other","id":-1,"name":"_Other","namespace":"numpy.polynomial._polybase.ABCPolyBase.__call__#0","upper_bound":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"arg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polybase._Other","id":-1,"name":"_Other","namespace":"numpy.polynomial._polybase.ABCPolyBase.__call__#0","upper_bound":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of ABCPolyBase","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polybase._Other","id":-1,"name":"_Other","namespace":"numpy.polynomial._polybase.ABCPolyBase.__call__#0","upper_bound":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polybase._Other","id":-1,"name":"_Other","namespace":"numpy.polynomial._polybase.ABCPolyBase.__call__#0","upper_bound":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"arg"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"arg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"decimal.Decimal","numbers.Real","numpy.object_"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of ABCPolyBase","ret_type":{".class":"UnionType","items":["numpy.float64","numpy.complex128"],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"arg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"decimal.Decimal","numbers.Real","numpy.object_"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of ABCPolyBase","ret_type":{".class":"UnionType","items":["numpy.float64","numpy.complex128"],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"arg"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"arg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"numbers.Complex"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of ABCPolyBase","ret_type":"numpy.complex128","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"arg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"numbers.Complex"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of ABCPolyBase","ret_type":"numpy.complex128","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"arg"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"arg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of ABCPolyBase","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"arg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of ABCPolyBase","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"arg"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"arg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of ABCPolyBase","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"arg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of ABCPolyBase","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"arg"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"arg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"arg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"arg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polybase._Other","id":-1,"name":"_Other","namespace":"numpy.polynomial._polybase.ABCPolyBase.__call__#0","upper_bound":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of ABCPolyBase","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polybase._Other","id":-1,"name":"_Other","namespace":"numpy.polynomial._polybase.ABCPolyBase.__call__#0","upper_bound":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polybase._Other","id":-1,"name":"_Other","namespace":"numpy.polynomial._polybase.ABCPolyBase.__call__#0","upper_bound":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"arg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"decimal.Decimal","numbers.Real","numpy.object_"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of ABCPolyBase","ret_type":{".class":"UnionType","items":["numpy.float64","numpy.complex128"],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"arg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"numbers.Complex"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of ABCPolyBase","ret_type":"numpy.complex128","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"arg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of ABCPolyBase","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"arg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of ABCPolyBase","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"arg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"__divmod__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__divmod__","name":"__divmod__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__divmod__ of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__eq__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__eq__","name":"__eq__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__eq__ of ABCPolyBase","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__floordiv__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__floordiv__","name":"__floordiv__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__floordiv__ of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__format__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__format__","name":"__format__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__format__ of ABCPolyBase","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__getstate__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__getstate__","name":"__getstate__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getstate__ of ABCPolyBase","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__hash__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__hash__","name":"__hash__","setter_type":null,"type":{".class":"NoneType"}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":[null,"coef","domain","window","symbol"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":[null,"coef","domain","window","symbol"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of ABCPolyBase","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__iter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__iter__","name":"__iter__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iter__ of ABCPolyBase","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.inexact"},"builtins.object"],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Iterator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__len__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__len__","name":"__len__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__len__ of ABCPolyBase","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__mod__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__mod__","name":"__mod__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mod__ of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__mul__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__mul__","name":"__mul__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mul__ of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__ne__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__ne__","name":"__ne__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ne__ of ABCPolyBase","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__neg__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__neg__","name":"__neg__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__neg__ of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__pos__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__pos__","name":"__pos__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__pos__ of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__pow__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__pow__","name":"__pow__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__pow__ of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__radd__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__radd__","name":"__radd__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__radd__ of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__rdivmod__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__rdivmod__","name":"__rdivmod__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__rdivmod__ of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__rfloordiv__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__rfloordiv__","name":"__rfloordiv__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__rfloordiv__ of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__rmod__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__rmod__","name":"__rmod__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__rmod__ of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__rmul__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__rmul__","name":"__rmul__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__rmul__ of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__rsub__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__rsub__","name":"__rsub__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__rsub__ of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__rtruediv__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__rtruediv__","name":"__rtruediv__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__rtruediv__ of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__setstate__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__setstate__","name":"__setstate__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__setstate__ of ABCPolyBase","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__sub__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__sub__","name":"__sub__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__sub__ of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__truediv__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.__truediv__","name":"__truediv__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__truediv__ of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_repr_latex_term":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["i","arg_str","needs_parens"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"numpy.polynomial._polybase.ABCPolyBase._repr_latex_term","name":"_repr_latex_term","original_first_arg":"i","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["i","arg_str","needs_parens"],"arg_types":["builtins.str","builtins.str","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_repr_latex_term of ABCPolyBase","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_staticmethod","is_ready","is_inferred"],"fullname":"numpy.polynomial._polybase.ABCPolyBase._repr_latex_term","name":"_repr_latex_term","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["i","arg_str","needs_parens"],"arg_types":["builtins.str","builtins.str","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_repr_latex_term of ABCPolyBase","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"_str_term_ascii":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["i","arg_str"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"numpy.polynomial._polybase.ABCPolyBase._str_term_ascii","name":"_str_term_ascii","original_first_arg":"i","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["i","arg_str"],"arg_types":["builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_str_term_ascii of ABCPolyBase","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_staticmethod","is_ready","is_inferred"],"fullname":"numpy.polynomial._polybase.ABCPolyBase._str_term_ascii","name":"_str_term_ascii","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["i","arg_str"],"arg_types":["builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_str_term_ascii of ABCPolyBase","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"_str_term_unicode":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":[null,"i","arg_str"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase._str_term_unicode","name":"_str_term_unicode","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"i","arg_str"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}},"builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_str_term_unicode of ABCPolyBase","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"numpy.polynomial._polybase.ABCPolyBase._str_term_unicode","name":"_str_term_unicode","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"i","arg_str"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}},"builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_str_term_unicode of ABCPolyBase","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"_subscript_mapping":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready"],"fullname":"numpy.polynomial._polybase.ABCPolyBase._subscript_mapping","name":"_subscript_mapping","setter_type":null,"type":{".class":"Instance","args":["builtins.int","builtins.str"],"extra_attrs":null,"type_ref":"typing.Mapping"}}},"_superscript_mapping":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready"],"fullname":"numpy.polynomial._polybase.ABCPolyBase._superscript_mapping","name":"_superscript_mapping","setter_type":null,"type":{".class":"Instance","args":["builtins.int","builtins.str"],"extra_attrs":null,"type_ref":"typing.Mapping"}}},"_symbol":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.polynomial._polybase.ABCPolyBase._symbol","name":"_symbol","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3}}},"_use_unicode":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready"],"fullname":"numpy.polynomial._polybase.ABCPolyBase._use_unicode","name":"_use_unicode","setter_type":null,"type":"builtins.bool"}},"basis":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["cls","deg","domain","window","symbol"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.basis","name":"basis","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["cls","deg","domain","window","symbol"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"basis of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.basis","name":"basis","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["cls","deg","domain","window","symbol"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"basis of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"basis_name":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.basis_name","name":"basis_name","setter_type":null,"type":{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}}},"cast":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["cls","series","domain","window"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.cast","name":"cast","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["cls","series","domain","window"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cast of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.cast","name":"cast","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["cls","series","domain","window"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cast of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"coef":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.coef","name":"coef","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"convert":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.polynomial._polybase.ABCPolyBase.convert","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":[null,"domain","kind","window"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.convert","name":"convert","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"domain","kind","window"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polybase._Other","id":-1,"name":"_Other","namespace":"numpy.polynomial._polybase.ABCPolyBase.convert#0","upper_bound":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"values":[],"variance":0}},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"convert of ABCPolyBase","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polybase._Other","id":-1,"name":"_Other","namespace":"numpy.polynomial._polybase.ABCPolyBase.convert#0","upper_bound":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polybase._Other","id":-1,"name":"_Other","namespace":"numpy.polynomial._polybase.ABCPolyBase.convert#0","upper_bound":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.convert","name":"convert","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"domain","kind","window"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polybase._Other","id":-1,"name":"_Other","namespace":"numpy.polynomial._polybase.ABCPolyBase.convert#0","upper_bound":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"values":[],"variance":0}},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"convert of ABCPolyBase","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polybase._Other","id":-1,"name":"_Other","namespace":"numpy.polynomial._polybase.ABCPolyBase.convert#0","upper_bound":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polybase._Other","id":-1,"name":"_Other","namespace":"numpy.polynomial._polybase.ABCPolyBase.convert#0","upper_bound":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3,5],"arg_names":[null,"domain","kind","window"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.convert","name":"convert","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":[null,"domain","kind","window"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polybase._Other","id":-1,"name":"_Other","namespace":"numpy.polynomial._polybase.ABCPolyBase.convert#1","upper_bound":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"values":[],"variance":0}},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"convert of ABCPolyBase","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polybase._Other","id":-1,"name":"_Other","namespace":"numpy.polynomial._polybase.ABCPolyBase.convert#1","upper_bound":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polybase._Other","id":-1,"name":"_Other","namespace":"numpy.polynomial._polybase.ABCPolyBase.convert#1","upper_bound":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.convert","name":"convert","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":[null,"domain","kind","window"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polybase._Other","id":-1,"name":"_Other","namespace":"numpy.polynomial._polybase.ABCPolyBase.convert#1","upper_bound":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"values":[],"variance":0}},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"convert of ABCPolyBase","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polybase._Other","id":-1,"name":"_Other","namespace":"numpy.polynomial._polybase.ABCPolyBase.convert#1","upper_bound":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polybase._Other","id":-1,"name":"_Other","namespace":"numpy.polynomial._polybase.ABCPolyBase.convert#1","upper_bound":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":[null,"domain","kind","window"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.convert","name":"convert","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":[null,"domain","kind","window"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"convert of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.convert","name":"convert","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":[null,"domain","kind","window"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"convert of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"domain","kind","window"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polybase._Other","id":-1,"name":"_Other","namespace":"numpy.polynomial._polybase.ABCPolyBase.convert#0","upper_bound":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"values":[],"variance":0}},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"convert of ABCPolyBase","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polybase._Other","id":-1,"name":"_Other","namespace":"numpy.polynomial._polybase.ABCPolyBase.convert#0","upper_bound":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polybase._Other","id":-1,"name":"_Other","namespace":"numpy.polynomial._polybase.ABCPolyBase.convert#0","upper_bound":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,3,5],"arg_names":[null,"domain","kind","window"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polybase._Other","id":-1,"name":"_Other","namespace":"numpy.polynomial._polybase.ABCPolyBase.convert#1","upper_bound":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"values":[],"variance":0}},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"convert of ABCPolyBase","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polybase._Other","id":-1,"name":"_Other","namespace":"numpy.polynomial._polybase.ABCPolyBase.convert#1","upper_bound":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polybase._Other","id":-1,"name":"_Other","namespace":"numpy.polynomial._polybase.ABCPolyBase.convert#1","upper_bound":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":[null,"domain","kind","window"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"convert of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"copy":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.copy","name":"copy","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"copy of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"cutdeg":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.cutdeg","name":"cutdeg","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cutdeg of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"degree":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.degree","name":"degree","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"degree of ABCPolyBase","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"deriv":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":[null,"m"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.deriv","name":"deriv","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":[null,"m"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"deriv of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"domain":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.domain","name":"domain","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"fit":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":["is_class"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.fit","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1,1,1,1,1,1],"arg_names":["cls","x","y","deg","domain","rcond","full","w","window","symbol"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.fit","name":"fit","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1,1,1,1],"arg_names":["cls","x","y","deg","domain","rcond","full","w","window","symbol"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fit of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_classmethod","is_ready","is_inferred"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.fit","name":"fit","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1,1,1,1],"arg_names":["cls","x","y","deg","domain","rcond","full","w","window","symbol"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fit of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1,1,3,5,5,5],"arg_names":["cls","x","y","deg","domain","rcond","full","w","window","symbol"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.fit","name":"fit","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,3,5,5,5],"arg_names":["cls","x","y","deg","domain","rcond","full","w","window","symbol"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fit of ABCPolyBase","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.inexact"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_classmethod","is_ready","is_inferred"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.fit","name":"fit","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,3,5,5,5],"arg_names":["cls","x","y","deg","domain","rcond","full","w","window","symbol"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fit of ABCPolyBase","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.inexact"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0,0,0,1,1,1],"arg_names":[null,null,null,null,null,null,null,"w","window","symbol"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.fit","name":"fit","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,0,1,1,1],"arg_names":[null,null,null,null,null,null,null,"w","window","symbol"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fit of ABCPolyBase","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.inexact"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_classmethod","is_ready","is_inferred"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.fit","name":"fit","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,0,1,1,1],"arg_names":[null,null,null,null,null,null,null,"w","window","symbol"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fit of ABCPolyBase","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.inexact"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1,1,1,1],"arg_names":["cls","x","y","deg","domain","rcond","full","w","window","symbol"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fit of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,3,5,5,5],"arg_names":["cls","x","y","deg","domain","rcond","full","w","window","symbol"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fit of ABCPolyBase","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.inexact"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,0,1,1,1],"arg_names":[null,null,null,null,null,null,null,"w","window","symbol"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fit of ABCPolyBase","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.inexact"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"fromroots":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["cls","roots","domain","window","symbol"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.fromroots","name":"fromroots","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["cls","roots","domain","window","symbol"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromroots of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.fromroots","name":"fromroots","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["cls","roots","domain","window","symbol"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fromroots of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"has_samecoef":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"other"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.has_samecoef","name":"has_samecoef","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"other"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"has_samecoef of ABCPolyBase","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"has_samedomain":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"other"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.has_samedomain","name":"has_samedomain","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"other"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"has_samedomain of ABCPolyBase","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"has_sametype":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.polynomial._polybase.ABCPolyBase.has_sametype","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"other"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.has_sametype","name":"has_sametype","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"other"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"has_sametype of ABCPolyBase","ret_type":"builtins.bool","type_guard":null,"type_is":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.has_sametype","name":"has_sametype","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"other"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"has_sametype of ABCPolyBase","ret_type":"builtins.bool","type_guard":null,"type_is":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"other"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.has_sametype","name":"has_sametype","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"other"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"has_sametype of ABCPolyBase","ret_type":{".class":"LiteralType","fallback":"builtins.bool","value":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.has_sametype","name":"has_sametype","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"other"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"has_sametype of ABCPolyBase","ret_type":{".class":"LiteralType","fallback":"builtins.bool","value":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"other"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"has_sametype of ABCPolyBase","ret_type":"builtins.bool","type_guard":null,"type_is":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"other"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"has_sametype of ABCPolyBase","ret_type":{".class":"LiteralType","fallback":"builtins.bool","value":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"has_samewindow":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"other"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.has_samewindow","name":"has_samewindow","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"other"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"has_samewindow of ABCPolyBase","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"identity":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["cls","domain","window","symbol"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.identity","name":"identity","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["cls","domain","window","symbol"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"identity of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.identity","name":"identity","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["cls","domain","window","symbol"],"arg_types":[{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"identity of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"integ":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":[null,"m","k","lbnd"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.integ","name":"integ","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":[null,"m","k","lbnd"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integ of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"linspace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":[null,"n","domain"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.linspace","name":"linspace","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":[null,"n","domain"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"linspace of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"mapparms":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.mapparms","name":"mapparms","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapparms of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"maxpower":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.maxpower","name":"maxpower","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.TypeAlias","source_any":null,"type_of_any":3}}},"roots":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.roots","name":"roots","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"roots of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"symbol":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.symbol","name":"symbol","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"symbol of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.symbol","name":"symbol","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"symbol of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"trim":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":[null,"tol"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.trim","name":"trim","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":[null,"tol"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trim of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"truncate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.truncate","name":"truncate","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"size"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"truncate of ABCPolyBase","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"window":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.polynomial._polybase.ABCPolyBase.window","name":"window","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polybase.ABCPolyBase.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","id":1,"name":"_NameCo","namespace":"numpy.polynomial._polybase.ABCPolyBase","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_NameCo"],"typeddict_type":null}},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"ClassVar":{".class":"SymbolTableNode","cross_ref":"typing.ClassVar","kind":"Gdef","module_hidden":true,"module_public":false},"Generic":{".class":"SymbolTableNode","cross_ref":"typing.Generic","kind":"Gdef","module_hidden":true,"module_public":false},"Iterator":{".class":"SymbolTableNode","cross_ref":"typing.Iterator","kind":"Gdef","module_hidden":true,"module_public":false},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"LiteralString":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.polynomial._polybase.LiteralString","name":"LiteralString","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3}}},"Mapping":{".class":"SymbolTableNode","cross_ref":"typing.Mapping","kind":"Gdef","module_hidden":true,"module_public":false},"Self":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.polynomial._polybase.Self","name":"Self","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.Self","source_any":null,"type_of_any":3}}},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef","module_hidden":true,"module_public":false},"SupportsIndex":{".class":"SymbolTableNode","cross_ref":"typing.SupportsIndex","kind":"Gdef","module_hidden":true,"module_public":false},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.polynomial._polybase.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.TypeAlias","source_any":null,"type_of_any":3}}},"TypeIs":{".class":"SymbolTableNode","cross_ref":"typing_extensions.TypeIs","kind":"Gdef","module_hidden":true,"module_public":false},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing_extensions.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"_AnyInt":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._AnyInt","kind":"Gdef","module_hidden":true,"module_public":false},"_AnyOther":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.polynomial._polybase._AnyOther","name":"_AnyOther","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.TypeAlias","source_any":null,"type_of_any":3}}},"_Array2":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._Array2","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeCoefObject_co":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._ArrayLikeCoefObject_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeCoef_co":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._ArrayLikeCoef_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeComplex_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeComplex_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeFloat_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeFloat_co","kind":"Gdef","module_hidden":true,"module_public":false},"_CoefLike_co":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._CoefLike_co","kind":"Gdef","module_hidden":true,"module_public":false},"_CoefSeries":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._CoefSeries","kind":"Gdef","module_hidden":true,"module_public":false},"_FloatLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._FloatLike_co","kind":"Gdef","module_hidden":true,"module_public":false},"_Hundred":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.polynomial._polybase._Hundred","name":"_Hundred","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.TypeAlias","source_any":null,"type_of_any":3}}},"_NameCo":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.polynomial._polybase._NameCo","name":"_NameCo","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}},"_NumberLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._NumberLike_co","kind":"Gdef","module_hidden":true,"module_public":false},"_Other":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polybase._Other","name":"_Other","upper_bound":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polybase.LiteralString","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"},"values":[],"variance":0}},"_Series":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._Series","kind":"Gdef","module_hidden":true,"module_public":false},"_SeriesLikeCoef_co":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._SeriesLikeCoef_co","kind":"Gdef","module_hidden":true,"module_public":false},"_SeriesLikeInt_co":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._SeriesLikeInt_co","kind":"Gdef","module_hidden":true,"module_public":false},"_Tuple2":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._Tuple2","kind":"Gdef","module_hidden":true,"module_public":false},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.polynomial._polybase.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial._polybase.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial._polybase.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial._polybase.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial._polybase.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial._polybase.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial._polybase.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"abc":{".class":"SymbolTableNode","cross_ref":"abc","kind":"Gdef","module_hidden":true,"module_public":false},"decimal":{".class":"SymbolTableNode","cross_ref":"decimal","kind":"Gdef","module_hidden":true,"module_public":false},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"npt":{".class":"SymbolTableNode","cross_ref":"numpy.typing","kind":"Gdef","module_hidden":true,"module_public":false},"numbers":{".class":"SymbolTableNode","cross_ref":"numbers","kind":"Gdef","module_hidden":true,"module_public":false},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/polynomial/_polybase.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/_polybase.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/_polybase.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..48a81b18e6da961ef2f3268206761997aac6dd8d --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/_polybase.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[28,4,20,21,1,2,3,5,17,19,1,1,1],"dep_prios":[5,5,10,5,10,10,10,5,5,10,5,30,30],"dependencies":["numpy.polynomial._polytypes","collections.abc","numpy.typing","numpy._typing","abc","decimal","numbers","typing","typing_extensions","numpy","builtins","_frozen_importlib","numpy._typing._nbit_base"],"hash":"af3279866ee9105c6addb372930efca6c668d050","id":"numpy.polynomial._polybase","ignore_all":true,"interface_hash":"b7db06ded49a0c83155345ef50a667d9328775f6","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/polynomial/_polybase.pyi","plugin_data":null,"size":8187,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/_polytypes.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/_polytypes.data.json new file mode 100644 index 0000000000000000000000000000000000000000..cec306603ff623e175daf86e33414daaa94e5a77 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/_polytypes.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.polynomial._polytypes","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef","module_hidden":true,"module_public":false},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"LiteralString":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes.LiteralString","name":"LiteralString","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3}}},"NoReturn":{".class":"SymbolTableNode","cross_ref":"typing.NoReturn","kind":"Gdef","module_hidden":true,"module_public":false},"Protocol":{".class":"SymbolTableNode","cross_ref":"typing.Protocol","kind":"Gdef","module_hidden":true,"module_public":false},"Self":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes.Self","name":"Self","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.Self","source_any":null,"type_of_any":3}}},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef","module_hidden":true,"module_public":false},"SupportsIndex":{".class":"SymbolTableNode","cross_ref":"typing.SupportsIndex","kind":"Gdef","module_hidden":true,"module_public":false},"SupportsInt":{".class":"SymbolTableNode","cross_ref":"typing.SupportsInt","kind":"Gdef","module_hidden":true,"module_public":false},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"_AnyDegrees":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.polynomial._polytypes._AnyDegrees","name":"_AnyDegrees","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"_AnyFuncVander":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.polynomial._polytypes._AnyFuncVander","name":"_AnyFuncVander","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"_AnyInt":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.polynomial._polytypes._AnyInt","name":"_AnyInt","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"_AnyValF":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.polynomial._polytypes._AnyValF","name":"_AnyValF","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"_Array1":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.polynomial._polytypes._Array1","name":"_Array1","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"_Array2":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.polynomial._polytypes._Array2","name":"_Array2","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"_ArrayLikeCoefObject_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.polynomial._polytypes._ArrayLikeCoefObject_co","name":"_ArrayLikeCoefObject_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"_ArrayLikeCoef_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.polynomial._polytypes._ArrayLikeCoef_co","name":"_ArrayLikeCoef_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"_ArrayLikeComplex_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeComplex_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeFloat_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeFloat_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeNumber_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeNumber_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeObject_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeObject_co","kind":"Gdef","module_hidden":true,"module_public":false},"_CoefArray":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.polynomial._polytypes._CoefArray","name":"_CoefArray","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"_CoefLike_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.polynomial._polytypes._CoefLike_co","name":"_CoefLike_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"_CoefObjectLike_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.polynomial._polytypes._CoefObjectLike_co","name":"_CoefObjectLike_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"_CoefSeries":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.polynomial._polytypes._CoefSeries","name":"_CoefSeries","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"_Companion":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.polynomial._polytypes._Companion","name":"_Companion","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"_ComplexArray":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.polynomial._polytypes._ComplexArray","name":"_ComplexArray","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"_ComplexLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._ComplexLike_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ComplexSeries":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.polynomial._polytypes._ComplexSeries","name":"_ComplexSeries","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"_FloatArray":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.polynomial._polytypes._FloatArray","name":"_FloatArray","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"_FloatLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._FloatLike_co","kind":"Gdef","module_hidden":true,"module_public":false},"_FloatSeries":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.polynomial._polytypes._FloatSeries","name":"_FloatSeries","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"_FullFitResult":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.polynomial._polytypes._FullFitResult","name":"_FullFitResult","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"_FuncBinOp":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncBinOp","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._Named"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.polynomial._polytypes._FuncBinOp","name":"_FuncBinOp","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncBinOp","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy.polynomial._polytypes._FuncBinOp","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.polynomial._polytypes","mro":["numpy.polynomial._polytypes._FuncBinOp","numpy.polynomial._polytypes._Named","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.polynomial._polytypes._FuncBinOp.__call__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":[null,"c1","c2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncBinOp.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"c1","c2"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncBinOp","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncBinOp","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncBinOp.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"c1","c2"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncBinOp","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncBinOp","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":[null,"c1","c2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncBinOp.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"c1","c2"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncBinOp","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncBinOp","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncBinOp.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"c1","c2"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncBinOp","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncBinOp","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":[null,"c1","c2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncBinOp.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"c1","c2"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncBinOp","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncBinOp","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncBinOp.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"c1","c2"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncBinOp","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncBinOp","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":[null,"c1","c2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncBinOp.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"c1","c2"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncBinOp","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncBinOp","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncBinOp.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"c1","c2"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncBinOp","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncBinOp","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"c1","c2"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncBinOp","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncBinOp","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"c1","c2"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncBinOp","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncBinOp","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"c1","c2"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncBinOp","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncBinOp","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"c1","c2"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncBinOp","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncBinOp","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._FuncBinOp.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncBinOp","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_Name_co"],"typeddict_type":null}},"_FuncCompanion":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncCompanion","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._Named"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.polynomial._polytypes._FuncCompanion","name":"_FuncCompanion","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncCompanion","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy.polynomial._polytypes._FuncCompanion","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.polynomial._polytypes","mro":["numpy.polynomial._polytypes._FuncCompanion","numpy.polynomial._polytypes._Named","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.polynomial._polytypes._FuncCompanion.__call__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"c"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncCompanion.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncCompanion","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncCompanion"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncCompanion","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncCompanion.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncCompanion","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncCompanion"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncCompanion","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"c"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncCompanion.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncCompanion","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncCompanion"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncCompanion","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncCompanion.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncCompanion","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncCompanion"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncCompanion","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"c"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncCompanion.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncCompanion","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncCompanion"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncCompanion","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncCompanion.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncCompanion","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncCompanion"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncCompanion","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncCompanion","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncCompanion"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncCompanion","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncCompanion","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncCompanion"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncCompanion","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncCompanion","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncCompanion"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncCompanion","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._FuncCompanion.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncCompanion","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncCompanion"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_Name_co"],"typeddict_type":null}},"_FuncDer":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncDer","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._Named"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.polynomial._polytypes._FuncDer","name":"_FuncDer","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncDer","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy.polynomial._polytypes._FuncDer","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.polynomial._polytypes","mro":["numpy.polynomial._polytypes._FuncDer","numpy.polynomial._polytypes._Named","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.polynomial._polytypes._FuncDer.__call__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":[null,"c","m","scl","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncDer.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":[null,"c","m","scl","axis"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncDer","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncDer"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncDer","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncDer.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":[null,"c","m","scl","axis"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncDer","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncDer"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncDer","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":[null,"c","m","scl","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncDer.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":[null,"c","m","scl","axis"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncDer","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncDer"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncDer","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncDer.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":[null,"c","m","scl","axis"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncDer","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncDer"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncDer","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":[null,"c","m","scl","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncDer.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":[null,"c","m","scl","axis"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncDer","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncDer"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncDer","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncDer.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":[null,"c","m","scl","axis"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncDer","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncDer"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncDer","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":[null,"c","m","scl","axis"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncDer","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncDer"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncDer","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":[null,"c","m","scl","axis"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncDer","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncDer"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncDer","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":[null,"c","m","scl","axis"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncDer","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncDer"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncDer","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._FuncDer.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncDer","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncDer"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_Name_co"],"typeddict_type":null}},"_FuncFit":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFit","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._Named"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.polynomial._polytypes._FuncFit","name":"_FuncFit","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFit","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy.polynomial._polytypes._FuncFit","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.polynomial._polytypes","mro":["numpy.polynomial._polytypes._FuncFit","numpy.polynomial._polytypes._Named","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.polynomial._polytypes._FuncFit.__call__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1,1,1],"arg_names":[null,"x","y","deg","rcond","full","w"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncFit.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1],"arg_names":[null,"x","y","deg","rcond","full","w"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFit","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFit"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncFit","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncFit.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1],"arg_names":[null,"x","y","deg","rcond","full","w"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFit","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFit"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncFit","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0,0,1],"arg_names":[null,null,null,null,null,null,"w"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncFit.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,1],"arg_names":[null,null,null,null,null,null,"w"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFit","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFit"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncFit","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncFit.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,1],"arg_names":[null,null,null,null,null,null,"w"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFit","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFit"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncFit","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1,3,5],"arg_names":[null,"x","y","deg","rcond","full","w"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncFit.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,3,5],"arg_names":[null,"x","y","deg","rcond","full","w"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFit","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFit"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncFit","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncFit.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,3,5],"arg_names":[null,"x","y","deg","rcond","full","w"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFit","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFit"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncFit","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1,1,1],"arg_names":[null,"x","y","deg","rcond","full","w"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncFit.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1],"arg_names":[null,"x","y","deg","rcond","full","w"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFit","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFit"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncFit","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncFit.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1],"arg_names":[null,"x","y","deg","rcond","full","w"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFit","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFit"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncFit","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0,0,1],"arg_names":[null,null,null,null,null,null,"w"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncFit.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,1],"arg_names":[null,null,null,null,null,null,"w"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFit","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFit"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncFit","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncFit.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,1],"arg_names":[null,null,null,null,null,null,"w"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFit","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFit"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncFit","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1,3,5],"arg_names":[null,"x","y","deg","rcond","full","w"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncFit.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,3,5],"arg_names":[null,"x","y","deg","rcond","full","w"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFit","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFit"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncFit","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncFit.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,3,5],"arg_names":[null,"x","y","deg","rcond","full","w"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFit","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFit"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncFit","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1,1,1],"arg_names":[null,"x","y","deg","rcond","full","w"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncFit.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1],"arg_names":[null,"x","y","deg","rcond","full","w"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFit","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFit"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncFit","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncFit.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1],"arg_names":[null,"x","y","deg","rcond","full","w"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFit","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFit"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncFit","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0,0,1],"arg_names":[null,null,null,null,null,null,"w"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncFit.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,1],"arg_names":[null,null,null,null,null,null,"w"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFit","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFit"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncFit","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncFit.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,1],"arg_names":[null,null,null,null,null,null,"w"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFit","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFit"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncFit","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1,3,5],"arg_names":[null,"x","y","deg","rcond","full","w"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncFit.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,3,5],"arg_names":[null,"x","y","deg","rcond","full","w"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFit","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFit"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncFit","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncFit.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,3,5],"arg_names":[null,"x","y","deg","rcond","full","w"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFit","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFit"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncFit","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1],"arg_names":[null,"x","y","deg","rcond","full","w"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFit","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFit"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncFit","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,1],"arg_names":[null,null,null,null,null,null,"w"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFit","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFit"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncFit","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1,3,5],"arg_names":[null,"x","y","deg","rcond","full","w"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFit","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFit"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncFit","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1],"arg_names":[null,"x","y","deg","rcond","full","w"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFit","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFit"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncFit","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,1],"arg_names":[null,null,null,null,null,null,"w"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFit","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFit"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncFit","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1,3,5],"arg_names":[null,"x","y","deg","rcond","full","w"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFit","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFit"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncFit","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1],"arg_names":[null,"x","y","deg","rcond","full","w"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFit","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFit"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncFit","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,1],"arg_names":[null,null,null,null,null,null,"w"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFit","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFit"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncFit","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1,3,5],"arg_names":[null,"x","y","deg","rcond","full","w"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFit","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFit"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncFit","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._FuncFit.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFit","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFit"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_Name_co"],"typeddict_type":null}},"_FuncFromRoots":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFromRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._Named"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.polynomial._polytypes._FuncFromRoots","name":"_FuncFromRoots","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFromRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy.polynomial._polytypes._FuncFromRoots","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.polynomial._polytypes","mro":["numpy.polynomial._polytypes._FuncFromRoots","numpy.polynomial._polytypes._Named","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.polynomial._polytypes._FuncFromRoots.__call__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"roots"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncFromRoots.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"roots"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFromRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFromRoots"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncFromRoots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncFromRoots.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"roots"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFromRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFromRoots"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncFromRoots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"roots"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncFromRoots.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"roots"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFromRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFromRoots"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncFromRoots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncFromRoots.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"roots"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFromRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFromRoots"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncFromRoots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"roots"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncFromRoots.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"roots"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFromRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFromRoots"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncFromRoots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncFromRoots.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"roots"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFromRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFromRoots"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncFromRoots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"roots"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFromRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFromRoots"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncFromRoots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"roots"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFromRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFromRoots"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncFromRoots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"roots"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFromRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFromRoots"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncFromRoots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._FuncFromRoots.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncFromRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFromRoots"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_Name_co"],"typeddict_type":null}},"_FuncGauss":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncGauss","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._Named"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.polynomial._polytypes._FuncGauss","name":"_FuncGauss","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncGauss","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy.polynomial._polytypes._FuncGauss","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.polynomial._polytypes","mro":["numpy.polynomial._polytypes._FuncGauss","numpy.polynomial._polytypes._Named","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"deg"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncGauss.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncGauss","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncGauss"},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncGauss","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._FuncGauss.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncGauss","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncGauss"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_Name_co"],"typeddict_type":null}},"_FuncInteg":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncInteg","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._Named"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.polynomial._polytypes._FuncInteg","name":"_FuncInteg","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncInteg","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy.polynomial._polytypes._FuncInteg","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.polynomial._polytypes","mro":["numpy.polynomial._polytypes._FuncInteg","numpy.polynomial._polytypes._Named","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.polynomial._polytypes._FuncInteg.__call__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1],"arg_names":[null,"c","m","k","lbnd","scl","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncInteg.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":[null,"c","m","k","lbnd","scl","axis"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncInteg","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncInteg"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncInteg","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncInteg.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":[null,"c","m","k","lbnd","scl","axis"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncInteg","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncInteg"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncInteg","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1],"arg_names":[null,"c","m","k","lbnd","scl","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncInteg.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":[null,"c","m","k","lbnd","scl","axis"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncInteg","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncInteg"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncInteg","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncInteg.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":[null,"c","m","k","lbnd","scl","axis"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncInteg","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncInteg"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncInteg","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1],"arg_names":[null,"c","m","k","lbnd","scl","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncInteg.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":[null,"c","m","k","lbnd","scl","axis"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncInteg","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncInteg"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncInteg","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncInteg.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":[null,"c","m","k","lbnd","scl","axis"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncInteg","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncInteg"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncInteg","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":[null,"c","m","k","lbnd","scl","axis"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncInteg","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncInteg"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncInteg","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":[null,"c","m","k","lbnd","scl","axis"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncInteg","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncInteg"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncInteg","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":[null,"c","m","k","lbnd","scl","axis"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncInteg","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncInteg"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncInteg","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._FuncInteg.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncInteg","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncInteg"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_Name_co"],"typeddict_type":null}},"_FuncLine":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncLine","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._Named"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.polynomial._polytypes._FuncLine","name":"_FuncLine","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncLine","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy.polynomial._polytypes._FuncLine","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.polynomial._polytypes","mro":["numpy.polynomial._polytypes._FuncLine","numpy.polynomial._polytypes._Named","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.polynomial._polytypes._FuncLine.__call__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":[null,"off","scl"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncLine.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"off","scl"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncLine","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncLine"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.polynomial._polytypes._FuncLine.__call__#0","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.polynomial._polytypes._FuncLine.__call__#0","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncLine","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.polynomial._polytypes._FuncLine.__call__#0","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncLine.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"off","scl"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncLine","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncLine"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.polynomial._polytypes._FuncLine.__call__#0","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.polynomial._polytypes._FuncLine.__call__#0","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncLine","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.polynomial._polytypes._FuncLine.__call__#0","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":[null,"off","scl"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncLine.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"off","scl"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncLine","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncLine"},"builtins.int","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncLine","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncLine.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"off","scl"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncLine","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncLine"},"builtins.int","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncLine","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":[null,"off","scl"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncLine.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"off","scl"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncLine","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncLine"},"builtins.float","builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncLine","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncLine.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"off","scl"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncLine","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncLine"},"builtins.float","builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncLine","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":[null,"off","scl"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncLine.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"off","scl"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncLine","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncLine"},"builtins.complex","builtins.complex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncLine","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncLine.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"off","scl"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncLine","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncLine"},"builtins.complex","builtins.complex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncLine","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":[null,"off","scl"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncLine.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"off","scl"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncLine","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncLine"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._SupportsCoefOps"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._SupportsCoefOps"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncLine","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncLine.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"off","scl"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncLine","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncLine"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._SupportsCoefOps"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._SupportsCoefOps"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncLine","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"off","scl"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncLine","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncLine"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.polynomial._polytypes._FuncLine.__call__#0","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.polynomial._polytypes._FuncLine.__call__#0","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncLine","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._ScalarT","id":-1,"name":"_ScalarT","namespace":"numpy.polynomial._polytypes._FuncLine.__call__#0","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"off","scl"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncLine","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncLine"},"builtins.int","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncLine","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"off","scl"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncLine","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncLine"},"builtins.float","builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncLine","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"off","scl"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncLine","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncLine"},"builtins.complex","builtins.complex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncLine","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"off","scl"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncLine","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncLine"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._SupportsCoefOps"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._SupportsCoefOps"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncLine","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._FuncLine.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncLine","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncLine"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_Name_co"],"typeddict_type":null}},"_FuncPoly2Ortho":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncPoly2Ortho","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._Named"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.polynomial._polytypes._FuncPoly2Ortho","name":"_FuncPoly2Ortho","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncPoly2Ortho","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy.polynomial._polytypes._FuncPoly2Ortho","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.polynomial._polytypes","mro":["numpy.polynomial._polytypes._FuncPoly2Ortho","numpy.polynomial._polytypes._Named","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.polynomial._polytypes._FuncPoly2Ortho.__call__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"pol"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncPoly2Ortho.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"pol"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncPoly2Ortho","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncPoly2Ortho"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncPoly2Ortho","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncPoly2Ortho.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"pol"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncPoly2Ortho","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncPoly2Ortho"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncPoly2Ortho","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"pol"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncPoly2Ortho.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"pol"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncPoly2Ortho","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncPoly2Ortho"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncPoly2Ortho","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncPoly2Ortho.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"pol"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncPoly2Ortho","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncPoly2Ortho"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncPoly2Ortho","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"pol"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncPoly2Ortho.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"pol"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncPoly2Ortho","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncPoly2Ortho"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncPoly2Ortho","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncPoly2Ortho.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"pol"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncPoly2Ortho","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncPoly2Ortho"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncPoly2Ortho","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"pol"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncPoly2Ortho","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncPoly2Ortho"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncPoly2Ortho","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"pol"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncPoly2Ortho","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncPoly2Ortho"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncPoly2Ortho","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"pol"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncPoly2Ortho","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncPoly2Ortho"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncPoly2Ortho","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._FuncPoly2Ortho.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncPoly2Ortho","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncPoly2Ortho"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_Name_co"],"typeddict_type":null}},"_FuncPow":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncPow","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._Named"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.polynomial._polytypes._FuncPow","name":"_FuncPow","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncPow","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy.polynomial._polytypes._FuncPow","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.polynomial._polytypes","mro":["numpy.polynomial._polytypes._FuncPow","numpy.polynomial._polytypes._Named","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.polynomial._polytypes._FuncPow.__call__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":[null,"c","pow","maxpower"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncPow.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"c","pow","maxpower"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncPow","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncPow"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncPow","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncPow.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"c","pow","maxpower"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncPow","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncPow"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncPow","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":[null,"c","pow","maxpower"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncPow.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"c","pow","maxpower"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncPow","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncPow"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncPow","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncPow.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"c","pow","maxpower"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncPow","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncPow"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncPow","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":[null,"c","pow","maxpower"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncPow.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"c","pow","maxpower"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncPow","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncPow"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncPow","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncPow.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"c","pow","maxpower"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncPow","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncPow"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncPow","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"c","pow","maxpower"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncPow","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncPow"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncPow","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"c","pow","maxpower"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncPow","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncPow"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncPow","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"c","pow","maxpower"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncPow","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncPow"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncPow","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._FuncPow.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncPow","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncPow"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_Name_co"],"typeddict_type":null}},"_FuncPts":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncPts","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._Named"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.polynomial._polytypes._FuncPts","name":"_FuncPts","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncPts","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy.polynomial._polytypes._FuncPts","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.polynomial._polytypes","mro":["numpy.polynomial._polytypes._FuncPts","numpy.polynomial._polytypes._Named","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"npts"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncPts.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"npts"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncPts","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncPts"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncPts","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._FuncPts.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncPts","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncPts"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_Name_co"],"typeddict_type":null}},"_FuncRoots":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._Named"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.polynomial._polytypes._FuncRoots","name":"_FuncRoots","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy.polynomial._polytypes._FuncRoots","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.polynomial._polytypes","mro":["numpy.polynomial._polytypes._FuncRoots","numpy.polynomial._polytypes._Named","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.polynomial._polytypes._FuncRoots.__call__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"c"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncRoots.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncRoots"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncRoots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncRoots.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncRoots"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncRoots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"c"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncRoots.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncRoots"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncRoots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncRoots.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncRoots"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncRoots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"c"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncRoots.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncRoots"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncRoots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncRoots.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncRoots"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncRoots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncRoots"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncRoots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncRoots"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncRoots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncRoots"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncRoots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._FuncRoots.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncRoots"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_Name_co"],"typeddict_type":null}},"_FuncUnOp":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncUnOp","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._Named"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.polynomial._polytypes._FuncUnOp","name":"_FuncUnOp","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncUnOp","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy.polynomial._polytypes._FuncUnOp","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.polynomial._polytypes","mro":["numpy.polynomial._polytypes._FuncUnOp","numpy.polynomial._polytypes._Named","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.polynomial._polytypes._FuncUnOp.__call__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"c"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncUnOp.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncUnOp","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncUnOp"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncUnOp","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncUnOp.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncUnOp","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncUnOp"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncUnOp","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"c"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncUnOp.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncUnOp","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncUnOp"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncUnOp","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncUnOp.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncUnOp","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncUnOp"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncUnOp","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"c"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncUnOp.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncUnOp","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncUnOp"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncUnOp","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncUnOp.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncUnOp","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncUnOp"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncUnOp","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncUnOp","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncUnOp"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncUnOp","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncUnOp","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncUnOp"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncUnOp","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncUnOp","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncUnOp"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncUnOp","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._FuncUnOp.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncUnOp","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncUnOp"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_Name_co"],"typeddict_type":null}},"_FuncVal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._Named"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.polynomial._polytypes._FuncVal","name":"_FuncVal","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy.polynomial._polytypes._FuncVal","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.polynomial._polytypes","mro":["numpy.polynomial._polytypes._FuncVal","numpy.polynomial._polytypes._Named","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.polynomial._polytypes._FuncVal.__call__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":[null,"x","c","tensor"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncVal.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"x","c","tensor"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncVal.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"x","c","tensor"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":[null,"x","c","tensor"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncVal.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"x","c","tensor"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncVal.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"x","c","tensor"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":[null,"x","c","tensor"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncVal.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"x","c","tensor"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncVal.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"x","c","tensor"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":[null,"x","c","tensor"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncVal.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"x","c","tensor"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncVal.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"x","c","tensor"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":[null,"x","c","tensor"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncVal.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"x","c","tensor"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncVal.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"x","c","tensor"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":[null,"x","c","tensor"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncVal.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"x","c","tensor"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._SupportsCoefOps"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncVal.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"x","c","tensor"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._SupportsCoefOps"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"x","c","tensor"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"x","c","tensor"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"x","c","tensor"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"x","c","tensor"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"x","c","tensor"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"x","c","tensor"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._SupportsCoefOps"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._FuncVal.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_Name_co"],"typeddict_type":null}},"_FuncVal2D":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal2D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._Named"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.polynomial._polytypes._FuncVal2D","name":"_FuncVal2D","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal2D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy.polynomial._polytypes._FuncVal2D","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.polynomial._polytypes","mro":["numpy.polynomial._polytypes._FuncVal2D","numpy.polynomial._polytypes._Named","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.polynomial._polytypes._FuncVal2D.__call__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","c"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncVal2D.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal2D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal2D"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal2D","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncVal2D.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal2D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal2D"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal2D","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","c"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncVal2D.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal2D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal2D"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal2D","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncVal2D.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal2D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal2D"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal2D","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","c"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncVal2D.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal2D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal2D"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal2D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncVal2D.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal2D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal2D"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal2D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","c"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncVal2D.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal2D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal2D"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal2D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncVal2D.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal2D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal2D"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal2D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","c"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncVal2D.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal2D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal2D"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal2D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncVal2D.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal2D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal2D"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal2D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","c"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncVal2D.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal2D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal2D"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal2D","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._SupportsCoefOps"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncVal2D.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal2D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal2D"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal2D","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._SupportsCoefOps"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal2D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal2D"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal2D","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal2D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal2D"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal2D","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal2D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal2D"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal2D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal2D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal2D"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal2D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal2D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal2D"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal2D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal2D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal2D"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal2D","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._SupportsCoefOps"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._FuncVal2D.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal2D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal2D"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_Name_co"],"typeddict_type":null}},"_FuncVal3D":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal3D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._Named"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.polynomial._polytypes._FuncVal3D","name":"_FuncVal3D","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal3D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy.polynomial._polytypes._FuncVal3D","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.polynomial._polytypes","mro":["numpy.polynomial._polytypes._FuncVal3D","numpy.polynomial._polytypes._Named","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.polynomial._polytypes._FuncVal3D.__call__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","c"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncVal3D.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal3D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal3D"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal3D","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncVal3D.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal3D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal3D"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal3D","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","c"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncVal3D.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal3D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal3D"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal3D","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncVal3D.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal3D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal3D"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal3D","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","c"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncVal3D.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal3D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal3D"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal3D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncVal3D.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal3D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal3D"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal3D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","c"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncVal3D.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal3D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal3D"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal3D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncVal3D.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal3D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal3D"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal3D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","c"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncVal3D.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal3D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal3D"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal3D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncVal3D.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal3D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal3D"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal3D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","c"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncVal3D.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal3D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal3D"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal3D","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._SupportsCoefOps"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncVal3D.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal3D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal3D"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal3D","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._SupportsCoefOps"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal3D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal3D"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal3D","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal3D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal3D"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal3D","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal3D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal3D"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal3D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal3D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal3D"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal3D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal3D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal3D"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal3D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal3D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal3D"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVal3D","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._SupportsCoefOps"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._FuncVal3D.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVal3D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal3D"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_Name_co"],"typeddict_type":null}},"_FuncValFromRoots":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValFromRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._Named"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.polynomial._polytypes._FuncValFromRoots","name":"_FuncValFromRoots","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValFromRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy.polynomial._polytypes._FuncValFromRoots","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.polynomial._polytypes","mro":["numpy.polynomial._polytypes._FuncValFromRoots","numpy.polynomial._polytypes._Named","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.polynomial._polytypes._FuncValFromRoots.__call__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":[null,"x","r","tensor"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncValFromRoots.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"x","r","tensor"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValFromRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValFromRoots"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncValFromRoots","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncValFromRoots.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"x","r","tensor"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValFromRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValFromRoots"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncValFromRoots","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":[null,"x","r","tensor"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncValFromRoots.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"x","r","tensor"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValFromRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValFromRoots"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncValFromRoots","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncValFromRoots.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"x","r","tensor"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValFromRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValFromRoots"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncValFromRoots","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":[null,"x","r","tensor"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncValFromRoots.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"x","r","tensor"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValFromRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValFromRoots"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncValFromRoots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncValFromRoots.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"x","r","tensor"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValFromRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValFromRoots"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncValFromRoots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":[null,"x","r","tensor"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncValFromRoots.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"x","r","tensor"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValFromRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValFromRoots"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncValFromRoots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncValFromRoots.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"x","r","tensor"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValFromRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValFromRoots"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncValFromRoots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":[null,"x","r","tensor"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncValFromRoots.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"x","r","tensor"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValFromRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValFromRoots"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncValFromRoots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncValFromRoots.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"x","r","tensor"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValFromRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValFromRoots"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncValFromRoots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":[null,"x","r","tensor"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncValFromRoots.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"x","r","tensor"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValFromRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValFromRoots"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncValFromRoots","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._SupportsCoefOps"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncValFromRoots.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"x","r","tensor"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValFromRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValFromRoots"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncValFromRoots","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._SupportsCoefOps"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"x","r","tensor"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValFromRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValFromRoots"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncValFromRoots","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"x","r","tensor"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValFromRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValFromRoots"},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncValFromRoots","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"x","r","tensor"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValFromRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValFromRoots"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncValFromRoots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"x","r","tensor"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValFromRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValFromRoots"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncValFromRoots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"x","r","tensor"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValFromRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValFromRoots"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncValFromRoots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":[null,"x","r","tensor"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValFromRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValFromRoots"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncValFromRoots","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._SupportsCoefOps"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._FuncValFromRoots.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValFromRoots","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValFromRoots"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_Name_co"],"typeddict_type":null}},"_FuncValND":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValND","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._Named"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.polynomial._polytypes._FuncValND","name":"_FuncValND","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValND","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy.polynomial._polytypes._FuncValND","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.polynomial._polytypes","mro":["numpy.polynomial._polytypes._FuncValND","numpy.polynomial._polytypes._Named","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.polynomial._polytypes._FuncValND.__call__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,2],"arg_names":[null,null,null,"args"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncValND.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,2],"arg_names":[null,null,null,"args"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValND","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValND"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncValND","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncValND.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,2],"arg_names":[null,null,null,"args"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValND","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValND"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncValND","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,2],"arg_names":[null,null,null,"args"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncValND.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,2],"arg_names":[null,null,null,"args"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValND","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValND"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncValND","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncValND.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,2],"arg_names":[null,null,null,"args"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValND","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValND"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncValND","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,2],"arg_names":[null,null,null,"args"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncValND.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,2],"arg_names":[null,null,null,"args"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValND","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValND"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncValND","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncValND.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,2],"arg_names":[null,null,null,"args"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValND","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValND"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncValND","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,2],"arg_names":[null,null,null,"args"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncValND.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,2],"arg_names":[null,null,null,"args"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValND","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValND"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncValND","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncValND.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,2],"arg_names":[null,null,null,"args"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValND","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValND"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncValND","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,2],"arg_names":[null,null,null,"args"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncValND.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,2],"arg_names":[null,null,null,"args"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValND","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValND"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncValND","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._SupportsCoefOps"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncValND.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,2],"arg_names":[null,null,null,"args"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValND","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValND"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncValND","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._SupportsCoefOps"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,2],"arg_names":[null,null,null,"args"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncValND.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,2],"arg_names":[null,null,null,"args"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValND","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValND"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncValND","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncValND.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,2],"arg_names":[null,null,null,"args"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValND","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValND"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncValND","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,2],"arg_names":[null,null,null,"args"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValND","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValND"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncValND","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,2],"arg_names":[null,null,null,"args"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValND","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValND"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncValND","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,2],"arg_names":[null,null,null,"args"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValND","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValND"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncValND","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,2],"arg_names":[null,null,null,"args"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValND","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValND"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncValND","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,2],"arg_names":[null,null,null,"args"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValND","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValND"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncValND","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._SupportsCoefOps"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,2],"arg_names":[null,null,null,"args"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValND","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValND"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncValND","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._FuncValND.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncValND","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValND"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_Name_co"],"typeddict_type":null}},"_FuncVander":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._Named"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.polynomial._polytypes._FuncVander","name":"_FuncVander","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy.polynomial._polytypes._FuncVander","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.polynomial._polytypes","mro":["numpy.polynomial._polytypes._FuncVander","numpy.polynomial._polytypes._Named","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.polynomial._polytypes._FuncVander.__call__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":[null,"x","deg"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncVander.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"x","deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVander","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncVander.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"x","deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVander","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":[null,"x","deg"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncVander.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"x","deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVander","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncVander.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"x","deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVander","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":[null,"x","deg"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncVander.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"x","deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVander","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncVander.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"x","deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVander","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":[null,"x","deg"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncVander.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"x","deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVander","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncVander.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"x","deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVander","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"x","deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVander","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"x","deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVander","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"x","deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVander","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"x","deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVander","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._FuncVander.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_Name_co"],"typeddict_type":null}},"_FuncVander2D":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander2D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._Named"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.polynomial._polytypes._FuncVander2D","name":"_FuncVander2D","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander2D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy.polynomial._polytypes._FuncVander2D","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.polynomial._polytypes","mro":["numpy.polynomial._polytypes._FuncVander2D","numpy.polynomial._polytypes._Named","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.polynomial._polytypes._FuncVander2D.__call__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","deg"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncVander2D.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander2D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander2D"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVander2D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncVander2D.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander2D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander2D"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVander2D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","deg"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncVander2D.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander2D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander2D"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVander2D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncVander2D.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander2D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander2D"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVander2D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","deg"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncVander2D.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander2D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander2D"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVander2D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncVander2D.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander2D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander2D"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVander2D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","deg"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncVander2D.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander2D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander2D"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVander2D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncVander2D.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander2D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander2D"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVander2D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander2D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander2D"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVander2D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander2D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander2D"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVander2D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander2D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander2D"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVander2D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"x","y","deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander2D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander2D"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVander2D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._FuncVander2D.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander2D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander2D"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_Name_co"],"typeddict_type":null}},"_FuncVander3D":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander3D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._Named"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.polynomial._polytypes._FuncVander3D","name":"_FuncVander3D","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander3D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy.polynomial._polytypes._FuncVander3D","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.polynomial._polytypes","mro":["numpy.polynomial._polytypes._FuncVander3D","numpy.polynomial._polytypes._Named","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.polynomial._polytypes._FuncVander3D.__call__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","deg"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncVander3D.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander3D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander3D"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVander3D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncVander3D.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander3D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander3D"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVander3D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","deg"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncVander3D.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander3D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander3D"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVander3D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncVander3D.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander3D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander3D"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVander3D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","deg"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncVander3D.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander3D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander3D"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVander3D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncVander3D.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander3D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander3D"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVander3D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","deg"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncVander3D.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander3D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander3D"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVander3D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncVander3D.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander3D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander3D"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVander3D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander3D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander3D"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVander3D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander3D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander3D"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVander3D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander3D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander3D"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVander3D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":[null,"x","y","z","deg"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander3D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander3D"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVander3D","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._FuncVander3D.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVander3D","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander3D"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_Name_co"],"typeddict_type":null}},"_FuncVanderND":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVanderND","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._Named"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.polynomial._polytypes._FuncVanderND","name":"_FuncVanderND","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVanderND","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy.polynomial._polytypes._FuncVanderND","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.polynomial._polytypes","mro":["numpy.polynomial._polytypes._FuncVanderND","numpy.polynomial._polytypes._Named","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.polynomial._polytypes._FuncVanderND.__call__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":[null,"vander_fs","points","degrees"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncVanderND.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"vander_fs","points","degrees"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVanderND","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVanderND"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":["typing.SupportsIndex"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVanderND","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncVanderND.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"vander_fs","points","degrees"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVanderND","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVanderND"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":["typing.SupportsIndex"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVanderND","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":[null,"vander_fs","points","degrees"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncVanderND.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"vander_fs","points","degrees"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVanderND","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVanderND"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":["typing.SupportsIndex"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVanderND","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncVanderND.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"vander_fs","points","degrees"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVanderND","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVanderND"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":["typing.SupportsIndex"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVanderND","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":[null,"vander_fs","points","degrees"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncVanderND.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"vander_fs","points","degrees"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVanderND","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVanderND"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":["typing.SupportsIndex"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVanderND","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncVanderND.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"vander_fs","points","degrees"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVanderND","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVanderND"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":["typing.SupportsIndex"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVanderND","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":[null,"vander_fs","points","degrees"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncVanderND.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"vander_fs","points","degrees"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVanderND","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVanderND"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":["typing.SupportsIndex"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVanderND","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncVanderND.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"vander_fs","points","degrees"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVanderND","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVanderND"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":["typing.SupportsIndex"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVanderND","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"vander_fs","points","degrees"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVanderND","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVanderND"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":["typing.SupportsIndex"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVanderND","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"vander_fs","points","degrees"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVanderND","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVanderND"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":["typing.SupportsIndex"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVanderND","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"vander_fs","points","degrees"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVanderND","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVanderND"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":["typing.SupportsIndex"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVanderND","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,"vander_fs","points","degrees"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVanderND","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVanderND"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":["typing.SupportsIndex"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncVanderND","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._FuncVanderND.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncVanderND","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVanderND"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_Name_co"],"typeddict_type":null}},"_FuncWeight":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncWeight","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._Named"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.polynomial._polytypes._FuncWeight","name":"_FuncWeight","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncWeight","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy.polynomial._polytypes._FuncWeight","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.polynomial._polytypes","mro":["numpy.polynomial._polytypes._FuncWeight","numpy.polynomial._polytypes._Named","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.polynomial._polytypes._FuncWeight.__call__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"c"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncWeight.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncWeight","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncWeight"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncWeight","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncWeight.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncWeight","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncWeight"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncWeight","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"c"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncWeight.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncWeight","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncWeight"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncWeight","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncWeight.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncWeight","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncWeight"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncWeight","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"c"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._FuncWeight.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncWeight","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncWeight"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncWeight","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._FuncWeight.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncWeight","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncWeight"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncWeight","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncWeight","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncWeight"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncWeight","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncWeight","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncWeight"},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncWeight","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"c"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncWeight","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncWeight"},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _FuncWeight","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._FuncWeight.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._FuncWeight","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncWeight"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_Name_co"],"typeddict_type":null}},"_IntLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._IntLike_co","kind":"Gdef","module_hidden":true,"module_public":false},"_Line":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.polynomial._polytypes._Line","name":"_Line","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"_Name_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","name":"_Name_co","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}},"_Named":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.polynomial._polytypes._Named","name":"_Named","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._Named","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy.polynomial._polytypes._Named","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.polynomial._polytypes","mro":["numpy.polynomial._polytypes._Named","builtins.object"],"names":{".class":"SymbolTable","__name__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial._polytypes._Named.__name__","name":"__name__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._Named","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._Named"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__name__ of _Named","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._Named","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy.polynomial._polytypes._Named.__name__","name":"__name__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._Named","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._Named"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__name__ of _Named","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._Named","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._Named.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"fullname":"numpy.polynomial._polytypes._Name_co","id":1,"name":"_Name_co","namespace":"numpy.polynomial._polytypes._Named","upper_bound":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._Named"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_Name_co"],"typeddict_type":null}},"_NestedSequence":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nested_sequence._NestedSequence","kind":"Gdef","module_hidden":true,"module_public":false},"_NumberLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._NumberLike_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ObjectArray":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.polynomial._polytypes._ObjectArray","name":"_ObjectArray","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"_ObjectSeries":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.polynomial._polytypes._ObjectSeries","name":"_ObjectSeries","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"_ScalarT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._ScalarT","name":"_ScalarT","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0}},"_Series":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.polynomial._polytypes._Series","name":"_Series","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"_SeriesLikeBool_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.polynomial._polytypes._SeriesLikeBool_co","name":"_SeriesLikeBool_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"_SeriesLikeCoef_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.polynomial._polytypes._SeriesLikeCoef_co","name":"_SeriesLikeCoef_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"_SeriesLikeComplex_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.polynomial._polytypes._SeriesLikeComplex_co","name":"_SeriesLikeComplex_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"_SeriesLikeFloat_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.polynomial._polytypes._SeriesLikeFloat_co","name":"_SeriesLikeFloat_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"_SeriesLikeInt_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.polynomial._polytypes._SeriesLikeInt_co","name":"_SeriesLikeInt_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"_SeriesLikeObject_co":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.polynomial._polytypes._SeriesLikeObject_co","name":"_SeriesLikeObject_co","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"_SupportsArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._SupportsArray","kind":"Gdef","module_hidden":true,"module_public":false},"_SupportsCoefOps":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.polynomial._polytypes._SupportsCoefOps","name":"_SupportsCoefOps","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._T_contra","id":1,"name":"_T_contra","namespace":"numpy.polynomial._polytypes._SupportsCoefOps","upper_bound":"builtins.object","values":[],"variance":2}]},"deletable_attributes":[],"deprecated":null,"flags":["is_protocol"],"fullname":"numpy.polynomial._polytypes._SupportsCoefOps","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.polynomial._polytypes","mro":["numpy.polynomial._polytypes._SupportsCoefOps","builtins.object"],"names":{".class":"SymbolTable","__add__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polytypes._SupportsCoefOps.__add__","name":"__add__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._T_contra","id":1,"name":"_T_contra","namespace":"numpy.polynomial._polytypes._SupportsCoefOps","upper_bound":"builtins.object","values":[],"variance":2}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._SupportsCoefOps"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._T_contra","id":1,"name":"_T_contra","namespace":"numpy.polynomial._polytypes._SupportsCoefOps","upper_bound":"builtins.object","values":[],"variance":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__add__ of _SupportsCoefOps","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__eq__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polytypes._SupportsCoefOps.__eq__","name":"__eq__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._T_contra","id":1,"name":"_T_contra","namespace":"numpy.polynomial._polytypes._SupportsCoefOps","upper_bound":"builtins.object","values":[],"variance":2}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._SupportsCoefOps"},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__eq__ of _SupportsCoefOps","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__mul__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polytypes._SupportsCoefOps.__mul__","name":"__mul__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._T_contra","id":1,"name":"_T_contra","namespace":"numpy.polynomial._polytypes._SupportsCoefOps","upper_bound":"builtins.object","values":[],"variance":2}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._SupportsCoefOps"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._T_contra","id":1,"name":"_T_contra","namespace":"numpy.polynomial._polytypes._SupportsCoefOps","upper_bound":"builtins.object","values":[],"variance":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mul__ of _SupportsCoefOps","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__ne__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polytypes._SupportsCoefOps.__ne__","name":"__ne__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._T_contra","id":1,"name":"_T_contra","namespace":"numpy.polynomial._polytypes._SupportsCoefOps","upper_bound":"builtins.object","values":[],"variance":2}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._SupportsCoefOps"},"builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__ne__ of _SupportsCoefOps","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__neg__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polytypes._SupportsCoefOps.__neg__","name":"__neg__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._T_contra","id":1,"name":"_T_contra","namespace":"numpy.polynomial._polytypes._SupportsCoefOps","upper_bound":"builtins.object","values":[],"variance":2}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._SupportsCoefOps"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__neg__ of _SupportsCoefOps","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__pos__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polytypes._SupportsCoefOps.__pos__","name":"__pos__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._T_contra","id":1,"name":"_T_contra","namespace":"numpy.polynomial._polytypes._SupportsCoefOps","upper_bound":"builtins.object","values":[],"variance":2}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._SupportsCoefOps"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__pos__ of _SupportsCoefOps","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__pow__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polytypes._SupportsCoefOps.__pow__","name":"__pow__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._T_contra","id":1,"name":"_T_contra","namespace":"numpy.polynomial._polytypes._SupportsCoefOps","upper_bound":"builtins.object","values":[],"variance":2}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._SupportsCoefOps"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._T_contra","id":1,"name":"_T_contra","namespace":"numpy.polynomial._polytypes._SupportsCoefOps","upper_bound":"builtins.object","values":[],"variance":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__pow__ of _SupportsCoefOps","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.Self","source_any":null,"type_of_any":3},"builtins.float"],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__radd__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polytypes._SupportsCoefOps.__radd__","name":"__radd__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._T_contra","id":1,"name":"_T_contra","namespace":"numpy.polynomial._polytypes._SupportsCoefOps","upper_bound":"builtins.object","values":[],"variance":2}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._SupportsCoefOps"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._T_contra","id":1,"name":"_T_contra","namespace":"numpy.polynomial._polytypes._SupportsCoefOps","upper_bound":"builtins.object","values":[],"variance":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__radd__ of _SupportsCoefOps","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__rmul__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polytypes._SupportsCoefOps.__rmul__","name":"__rmul__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._T_contra","id":1,"name":"_T_contra","namespace":"numpy.polynomial._polytypes._SupportsCoefOps","upper_bound":"builtins.object","values":[],"variance":2}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._SupportsCoefOps"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._T_contra","id":1,"name":"_T_contra","namespace":"numpy.polynomial._polytypes._SupportsCoefOps","upper_bound":"builtins.object","values":[],"variance":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__rmul__ of _SupportsCoefOps","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__rsub__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polytypes._SupportsCoefOps.__rsub__","name":"__rsub__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._T_contra","id":1,"name":"_T_contra","namespace":"numpy.polynomial._polytypes._SupportsCoefOps","upper_bound":"builtins.object","values":[],"variance":2}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._SupportsCoefOps"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._T_contra","id":1,"name":"_T_contra","namespace":"numpy.polynomial._polytypes._SupportsCoefOps","upper_bound":"builtins.object","values":[],"variance":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__rsub__ of _SupportsCoefOps","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__sub__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.polynomial._polytypes._SupportsCoefOps.__sub__","name":"__sub__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._T_contra","id":1,"name":"_T_contra","namespace":"numpy.polynomial._polytypes._SupportsCoefOps","upper_bound":"builtins.object","values":[],"variance":2}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._SupportsCoefOps"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._T_contra","id":1,"name":"_T_contra","namespace":"numpy.polynomial._polytypes._SupportsCoefOps","upper_bound":"builtins.object","values":[],"variance":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__sub__ of _SupportsCoefOps","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._SupportsCoefOps.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._T_contra","id":1,"name":"_T_contra","namespace":"numpy.polynomial._polytypes._SupportsCoefOps","upper_bound":"builtins.object","values":[],"variance":2}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._SupportsCoefOps"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_T_contra"],"typeddict_type":null}},"_T":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._T","name":"_T","upper_bound":"builtins.object","values":[],"variance":0}},"_T_contra":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial._polytypes._T_contra","name":"_T_contra","upper_bound":"builtins.object","values":[],"variance":2}},"_Tuple2":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.polynomial._polytypes._Tuple2","name":"_Tuple2","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial._polytypes.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial._polytypes.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial._polytypes.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial._polytypes.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial._polytypes.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial._polytypes.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"npt":{".class":"SymbolTableNode","cross_ref":"numpy.typing","kind":"Gdef","module_hidden":true,"module_public":false},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false},"type_check_only":{".class":"SymbolTableNode","cross_ref":"typing.type_check_only","kind":"Gdef","module_hidden":true,"module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/polynomial/_polytypes.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/_polytypes.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/_polytypes.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..33226bcfb1b325ba175fbd1eb9332df42925b679 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/_polytypes.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[3,20,21,4,19,1,1,1,1,1,1,1,1],"dep_prios":[5,10,5,5,10,5,30,30,30,30,30,30,30],"dependencies":["collections.abc","numpy.typing","numpy._typing","typing","numpy","builtins","_frozen_importlib","_typeshed","abc","numpy._typing._array_like","numpy._typing._nbit_base","numpy._typing._nested_sequence","numpy._typing._scalars"],"hash":"e03bf014baeb69d4b7c05e7dc47c3a1340c19f80","id":"numpy.polynomial._polytypes","ignore_all":true,"interface_hash":"e1a078520ae5c378aab5ccbbb15d2ee0fd7b90a4","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/polynomial/_polytypes.pyi","plugin_data":null,"size":22382,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/chebyshev.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/chebyshev.data.json new file mode 100644 index 0000000000000000000000000000000000000000..a37acf1a94e95cd580f2b485c131fc05a6ba4c6a --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/chebyshev.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.polynomial.chebyshev","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","ABCPolyBase":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polybase.ABCPolyBase","kind":"Gdef","module_hidden":true,"module_public":false},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef","module_hidden":true,"module_public":false},"Chebyshev":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"T"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.polynomial.chebyshev.Chebyshev","name":"Chebyshev","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.polynomial.chebyshev.Chebyshev","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.polynomial.chebyshev","mro":["numpy.polynomial.chebyshev.Chebyshev","numpy.polynomial._polybase.ABCPolyBase","abc.ABC","builtins.object"],"names":{".class":"SymbolTable","interpolate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":["is_class"],"fullname":"numpy.polynomial.chebyshev.Chebyshev.interpolate","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1],"arg_names":["cls","func","deg","domain","args"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial.chebyshev.Chebyshev.interpolate","name":"interpolate","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1],"arg_names":["cls","func","deg","domain","args"],"arg_types":[{".class":"TypeType","item":"numpy.polynomial.chebyshev.Chebyshev"},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"interpolate of Chebyshev","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial.chebyshev.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_classmethod","is_ready","is_inferred"],"fullname":"numpy.polynomial.chebyshev.Chebyshev.interpolate","name":"interpolate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,1],"arg_names":["cls","func","deg","domain","args"],"arg_types":[{".class":"TypeType","item":"numpy.polynomial.chebyshev.Chebyshev"},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"interpolate of Chebyshev","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial.chebyshev.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,3],"arg_names":["cls","func","deg","domain","args"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial.chebyshev.Chebyshev.interpolate","name":"interpolate","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0,0,1,3],"arg_names":["cls","func","deg","domain","args"],"arg_types":[{".class":"TypeType","item":"numpy.polynomial.chebyshev.Chebyshev"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"interpolate of Chebyshev","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial.chebyshev.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_classmethod","is_ready","is_inferred"],"fullname":"numpy.polynomial.chebyshev.Chebyshev.interpolate","name":"interpolate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1,3],"arg_names":["cls","func","deg","domain","args"],"arg_types":[{".class":"TypeType","item":"numpy.polynomial.chebyshev.Chebyshev"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"interpolate of Chebyshev","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial.chebyshev.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0],"arg_names":["cls","func","deg","domain","args"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.polynomial.chebyshev.Chebyshev.interpolate","name":"interpolate","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":["cls","func","deg","domain","args"],"arg_types":[{".class":"TypeType","item":"numpy.polynomial.chebyshev.Chebyshev"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"interpolate of Chebyshev","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial.chebyshev.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_classmethod","is_ready","is_inferred"],"fullname":"numpy.polynomial.chebyshev.Chebyshev.interpolate","name":"interpolate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":["cls","func","deg","domain","args"],"arg_types":[{".class":"TypeType","item":"numpy.polynomial.chebyshev.Chebyshev"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"interpolate of Chebyshev","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial.chebyshev.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,1,1],"arg_names":["cls","func","deg","domain","args"],"arg_types":[{".class":"TypeType","item":"numpy.polynomial.chebyshev.Chebyshev"},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"interpolate of Chebyshev","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial.chebyshev.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1,3],"arg_names":["cls","func","deg","domain","args"],"arg_types":[{".class":"TypeType","item":"numpy.polynomial.chebyshev.Chebyshev"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"interpolate of Chebyshev","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial.chebyshev.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":["cls","func","deg","domain","args"],"arg_types":[{".class":"TypeType","item":"numpy.polynomial.chebyshev.Chebyshev"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"interpolate of Chebyshev","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial.chebyshev.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial.chebyshev.Chebyshev.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.polynomial.chebyshev.Chebyshev","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Concatenate":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.polynomial.chebyshev.Concatenate","name":"Concatenate","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial.chebyshev.Concatenate","source_any":null,"type_of_any":3}}},"Final":{".class":"SymbolTableNode","cross_ref":"typing.Final","kind":"Gdef","module_hidden":true,"module_public":false},"Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef","module_hidden":true,"module_public":false},"L":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"Self":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.polynomial.chebyshev.Self","name":"Self","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial.chebyshev.Self","source_any":null,"type_of_any":3}}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"_Array1":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._Array1","kind":"Gdef","module_hidden":true,"module_public":false},"_Array2":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._Array2","kind":"Gdef","module_hidden":true,"module_public":false},"_CoefSeries":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._CoefSeries","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncBinOp":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncBinOp","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncCompanion":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncCompanion","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncDer":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncDer","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncFit":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncFit","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncFromRoots":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncFromRoots","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncGauss":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncGauss","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncInteg":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncInteg","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncLine":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncLine","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncPoly2Ortho":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncPoly2Ortho","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncPow":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncPow","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncPts":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncPts","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncRoots":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncRoots","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncUnOp":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncUnOp","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVal":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVal","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVal2D":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVal2D","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVal3D":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVal3D","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncValFromRoots":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncValFromRoots","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVander":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVander","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVander2D":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVander2D","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVander3D":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVander3D","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncWeight":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncWeight","kind":"Gdef","module_hidden":true,"module_public":false},"_IntLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._IntLike_co","kind":"Gdef","module_hidden":true,"module_public":false},"_NumberOrObjectT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial.chebyshev._NumberOrObjectT","name":"_NumberOrObjectT","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0}},"_RT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial.chebyshev._RT","name":"_RT","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0}},"_Series":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._Series","kind":"Gdef","module_hidden":true,"module_public":false},"_SeriesLikeCoef_co":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._SeriesLikeCoef_co","kind":"Gdef","module_hidden":true,"module_public":false},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.polynomial.chebyshev.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.chebyshev.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.chebyshev.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.chebyshev.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.chebyshev.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.chebyshev.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.chebyshev.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_cseries_to_zseries":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["c"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.polynomial.chebyshev._cseries_to_zseries","name":"_cseries_to_zseries","original_first_arg":"c","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["c"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_cseries_to_zseries","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial.chebyshev._NumberOrObjectT","id":-1,"name":"_NumberOrObjectT","namespace":"numpy.polynomial.chebyshev._cseries_to_zseries","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0}]}}},"_zseries_der":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["zs"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.polynomial.chebyshev._zseries_der","name":"_zseries_der","original_first_arg":"zs","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["zs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_zseries_der","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial.chebyshev._NumberOrObjectT","id":-1,"name":"_NumberOrObjectT","namespace":"numpy.polynomial.chebyshev._zseries_der","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0}]}}},"_zseries_div":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["z1","z2"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.polynomial.chebyshev._zseries_div","name":"_zseries_div","original_first_arg":"z1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["z1","z2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_zseries_div","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial.chebyshev._NumberOrObjectT","id":-1,"name":"_NumberOrObjectT","namespace":"numpy.polynomial.chebyshev._zseries_div","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0}]}}},"_zseries_int":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["zs"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.polynomial.chebyshev._zseries_int","name":"_zseries_int","original_first_arg":"zs","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["zs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_zseries_int","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial.chebyshev._NumberOrObjectT","id":-1,"name":"_NumberOrObjectT","namespace":"numpy.polynomial.chebyshev._zseries_int","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0}]}}},"_zseries_mul":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["z1","z2"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.polynomial.chebyshev._zseries_mul","name":"_zseries_mul","original_first_arg":"z1","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["z1","z2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_zseries_mul","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial.chebyshev._NumberOrObjectT","id":-1,"name":"_NumberOrObjectT","namespace":"numpy.polynomial.chebyshev._zseries_mul","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0}]}}},"_zseries_to_cseries":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["zs"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.polynomial.chebyshev._zseries_to_cseries","name":"_zseries_to_cseries","original_first_arg":"zs","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["zs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_zseries_to_cseries","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial.chebyshev._NumberOrObjectT","id":-1,"name":"_NumberOrObjectT","namespace":"numpy.polynomial.chebyshev._zseries_to_cseries","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0}]}}},"cheb2poly":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.chebyshev.cheb2poly","name":"cheb2poly","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"cheb2poly"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncUnOp"}}},"chebadd":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.chebyshev.chebadd","name":"chebadd","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"chebadd"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"}}},"chebcompanion":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.chebyshev.chebcompanion","name":"chebcompanion","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"chebcompanion"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncCompanion"}}},"chebder":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.chebyshev.chebder","name":"chebder","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"chebder"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncDer"}}},"chebdiv":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.chebyshev.chebdiv","name":"chebdiv","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"chebdiv"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"}}},"chebdomain":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy.polynomial.chebyshev.chebdomain","name":"chebdomain","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"chebfit":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.chebyshev.chebfit","name":"chebfit","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"chebfit"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFit"}}},"chebfromroots":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.chebyshev.chebfromroots","name":"chebfromroots","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"chebfromroots"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFromRoots"}}},"chebgauss":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.chebyshev.chebgauss","name":"chebgauss","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"chebgauss"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncGauss"}}},"chebgrid2d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.chebyshev.chebgrid2d","name":"chebgrid2d","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"chebgrid2d"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal2D"}}},"chebgrid3d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.chebyshev.chebgrid3d","name":"chebgrid3d","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"chebgrid3d"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal3D"}}},"chebint":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.chebyshev.chebint","name":"chebint","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"chebint"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncInteg"}}},"chebinterpolate":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.polynomial.chebyshev.chebinterpolate","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["func","deg","args"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.chebyshev.chebinterpolate","name":"chebinterpolate","original_first_arg":"func","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["func","deg","args"],"arg_types":["numpy.ufunc",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chebinterpolate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.chebyshev.chebinterpolate","name":"chebinterpolate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["func","deg","args"],"arg_types":["numpy.ufunc",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chebinterpolate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["func","deg","args"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.chebyshev.chebinterpolate","name":"chebinterpolate","original_first_arg":"func","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["func","deg","args"],"arg_types":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial.chebyshev._RT","id":-1,"name":"_RT","namespace":"numpy.polynomial.chebyshev.chebinterpolate#1","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chebinterpolate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial.chebyshev._RT","id":-1,"name":"_RT","namespace":"numpy.polynomial.chebyshev.chebinterpolate#1","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.chebyshev.chebinterpolate","name":"chebinterpolate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["func","deg","args"],"arg_types":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial.chebyshev._RT","id":-1,"name":"_RT","namespace":"numpy.polynomial.chebyshev.chebinterpolate#1","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chebinterpolate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial.chebyshev._RT","id":-1,"name":"_RT","namespace":"numpy.polynomial.chebyshev.chebinterpolate#1","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["func","deg","args"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.chebyshev.chebinterpolate","name":"chebinterpolate","original_first_arg":"func","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["func","deg","args"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chebinterpolate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial.chebyshev._RT","id":-1,"name":"_RT","namespace":"numpy.polynomial.chebyshev.chebinterpolate","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.chebyshev.chebinterpolate","name":"chebinterpolate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["func","deg","args"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chebinterpolate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial.chebyshev._RT","id":-1,"name":"_RT","namespace":"numpy.polynomial.chebyshev.chebinterpolate","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["func","deg","args"],"arg_types":["numpy.ufunc",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chebinterpolate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["func","deg","args"],"arg_types":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial.chebyshev._RT","id":-1,"name":"_RT","namespace":"numpy.polynomial.chebyshev.chebinterpolate#1","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chebinterpolate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial.chebyshev._RT","id":-1,"name":"_RT","namespace":"numpy.polynomial.chebyshev.chebinterpolate#1","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["func","deg","args"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chebinterpolate","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial.chebyshev._RT","id":-1,"name":"_RT","namespace":"numpy.polynomial.chebyshev.chebinterpolate","upper_bound":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.int","builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.number"},{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"numpy.object_"],"uses_pep604_syntax":true},"values":[],"variance":0}]}]}}},"chebline":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.chebyshev.chebline","name":"chebline","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"chebline"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncLine"}}},"chebmul":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.chebyshev.chebmul","name":"chebmul","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"chebmul"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"}}},"chebmulx":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.chebyshev.chebmulx","name":"chebmulx","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"chebmulx"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncUnOp"}}},"chebone":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy.polynomial.chebyshev.chebone","name":"chebone","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"chebpow":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.chebyshev.chebpow","name":"chebpow","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"chebpow"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncPow"}}},"chebpts1":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.chebyshev.chebpts1","name":"chebpts1","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"chebpts1"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncPts"}}},"chebpts2":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.chebyshev.chebpts2","name":"chebpts2","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"chebpts2"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncPts"}}},"chebroots":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.chebyshev.chebroots","name":"chebroots","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"chebroots"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncRoots"}}},"chebsub":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.chebyshev.chebsub","name":"chebsub","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"chebsub"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"}}},"chebtrim":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial.polyutils.trimcoef","kind":"Gdef"},"chebval":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.chebyshev.chebval","name":"chebval","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"chebval"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal"}}},"chebval2d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.chebyshev.chebval2d","name":"chebval2d","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"chebval2d"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal2D"}}},"chebval3d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.chebyshev.chebval3d","name":"chebval3d","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"chebval3d"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal3D"}}},"chebvalfromroots":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.chebyshev.chebvalfromroots","name":"chebvalfromroots","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"chebvalfromroots"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValFromRoots"}}},"chebvander":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.chebyshev.chebvander","name":"chebvander","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"chebvander"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander"}}},"chebvander2d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.chebyshev.chebvander2d","name":"chebvander2d","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"chebvander2d"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander2D"}}},"chebvander3d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.chebyshev.chebvander3d","name":"chebvander3d","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"chebvander3d"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander3D"}}},"chebweight":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.chebyshev.chebweight","name":"chebweight","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"chebweight"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncWeight"}}},"chebx":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy.polynomial.chebyshev.chebx","name":"chebx","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"chebzero":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy.polynomial.chebyshev.chebzero","name":"chebzero","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"npt":{".class":"SymbolTableNode","cross_ref":"numpy.typing","kind":"Gdef","module_hidden":true,"module_public":false},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false},"poly2cheb":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.chebyshev.poly2cheb","name":"poly2cheb","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"poly2cheb"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncPoly2Ortho"}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/polynomial/chebyshev.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/chebyshev.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/chebyshev.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..a591d85769e3325528bc667b027426be6233199b --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/chebyshev.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[9,10,38,1,6,7,2,5,1,1,1],"dep_prios":[5,5,5,5,10,5,5,10,5,30,30],"dependencies":["numpy.polynomial._polybase","numpy.polynomial._polytypes","numpy.polynomial.polyutils","collections.abc","numpy.typing","numpy._typing","typing","numpy","builtins","_frozen_importlib","abc"],"hash":"7c7a40b9ec9226c11875af19eb693aa5ad9a7b72","id":"numpy.polynomial.chebyshev","ignore_all":true,"interface_hash":"90d299b45b63ee3f88d26fc2eacb11fecfd4a8a8","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/polynomial/chebyshev.pyi","plugin_data":null,"size":4787,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/hermite.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/hermite.data.json new file mode 100644 index 0000000000000000000000000000000000000000..89ffa1e42219f406799b784e175a80f7929e33b9 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/hermite.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.polynomial.hermite","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","ABCPolyBase":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polybase.ABCPolyBase","kind":"Gdef","module_hidden":true,"module_public":false},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"Final":{".class":"SymbolTableNode","cross_ref":"typing.Final","kind":"Gdef","module_hidden":true,"module_public":false},"Hermite":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"H"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.polynomial.hermite.Hermite","name":"Hermite","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.polynomial.hermite.Hermite","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.polynomial.hermite","mro":["numpy.polynomial.hermite.Hermite","numpy.polynomial._polybase.ABCPolyBase","abc.ABC","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial.hermite.Hermite.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.polynomial.hermite.Hermite","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"L":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"_Array1":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._Array1","kind":"Gdef","module_hidden":true,"module_public":false},"_Array2":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._Array2","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncBinOp":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncBinOp","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncCompanion":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncCompanion","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncDer":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncDer","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncFit":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncFit","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncFromRoots":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncFromRoots","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncGauss":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncGauss","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncInteg":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncInteg","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncLine":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncLine","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncPoly2Ortho":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncPoly2Ortho","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncPow":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncPow","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncRoots":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncRoots","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncUnOp":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncUnOp","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVal":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVal","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVal2D":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVal2D","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVal3D":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVal3D","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncValFromRoots":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncValFromRoots","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVander":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVander","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVander2D":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVander2D","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVander3D":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVander3D","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncWeight":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncWeight","kind":"Gdef","module_hidden":true,"module_public":false},"_ND":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial.hermite._ND","name":"_ND","upper_bound":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"values":[],"variance":0}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.polynomial.hermite.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_normed_hermite_n":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x","n"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.polynomial.hermite._normed_hermite_n","name":"_normed_hermite_n","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x","n"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial.hermite._ND","id":-1,"name":"_ND","namespace":"numpy.polynomial.hermite._normed_hermite_n","upper_bound":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"values":[],"variance":0},{".class":"Instance","args":["numpy.float64"],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},{".class":"UnionType","items":["builtins.int",{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_normed_hermite_n","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial.hermite._ND","id":-1,"name":"_ND","namespace":"numpy.polynomial.hermite._normed_hermite_n","upper_bound":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"values":[],"variance":0},{".class":"Instance","args":["numpy.float64"],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial.hermite._ND","id":-1,"name":"_ND","namespace":"numpy.polynomial.hermite._normed_hermite_n","upper_bound":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"values":[],"variance":0}]}}},"herm2poly":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite.herm2poly","name":"herm2poly","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"herm2poly"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncUnOp"}}},"hermadd":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite.hermadd","name":"hermadd","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermadd"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"}}},"hermcompanion":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite.hermcompanion","name":"hermcompanion","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermcompanion"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncCompanion"}}},"hermder":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite.hermder","name":"hermder","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermder"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncDer"}}},"hermdiv":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite.hermdiv","name":"hermdiv","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermdiv"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"}}},"hermdomain":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy.polynomial.hermite.hermdomain","name":"hermdomain","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"hermfit":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite.hermfit","name":"hermfit","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermfit"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFit"}}},"hermfromroots":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite.hermfromroots","name":"hermfromroots","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermfromroots"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFromRoots"}}},"hermgauss":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite.hermgauss","name":"hermgauss","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermgauss"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncGauss"}}},"hermgrid2d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite.hermgrid2d","name":"hermgrid2d","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermgrid2d"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal2D"}}},"hermgrid3d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite.hermgrid3d","name":"hermgrid3d","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermgrid3d"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal3D"}}},"hermint":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite.hermint","name":"hermint","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermint"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncInteg"}}},"hermline":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite.hermline","name":"hermline","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermline"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncLine"}}},"hermmul":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite.hermmul","name":"hermmul","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermmul"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"}}},"hermmulx":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite.hermmulx","name":"hermmulx","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermmulx"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncUnOp"}}},"hermone":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy.polynomial.hermite.hermone","name":"hermone","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"hermpow":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite.hermpow","name":"hermpow","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermpow"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncPow"}}},"hermroots":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite.hermroots","name":"hermroots","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermroots"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncRoots"}}},"hermsub":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite.hermsub","name":"hermsub","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermsub"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"}}},"hermtrim":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial.polyutils.trimcoef","kind":"Gdef"},"hermval":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite.hermval","name":"hermval","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermval"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal"}}},"hermval2d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite.hermval2d","name":"hermval2d","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermval2d"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal2D"}}},"hermval3d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite.hermval3d","name":"hermval3d","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermval3d"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal3D"}}},"hermvalfromroots":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite.hermvalfromroots","name":"hermvalfromroots","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermvalfromroots"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValFromRoots"}}},"hermvander":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite.hermvander","name":"hermvander","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermvander"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander"}}},"hermvander2d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite.hermvander2d","name":"hermvander2d","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermvander2d"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander2D"}}},"hermvander3d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite.hermvander3d","name":"hermvander3d","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermvander3d"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander3D"}}},"hermweight":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite.hermweight","name":"hermweight","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermweight"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncWeight"}}},"hermx":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy.polynomial.hermite.hermx","name":"hermx","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"hermzero":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy.polynomial.hermite.hermzero","name":"hermzero","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"poly2herm":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite.poly2herm","name":"poly2herm","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"poly2herm"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncPoly2Ortho"}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/polynomial/hermite.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/hermite.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/hermite.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..8d33f1a6b8823689b2ff78c64fed7991b97df696 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/hermite.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[6,7,31,1,4,1,1,1],"dep_prios":[5,5,5,5,10,5,30,30],"dependencies":["numpy.polynomial._polybase","numpy.polynomial._polytypes","numpy.polynomial.polyutils","typing","numpy","builtins","_frozen_importlib","abc"],"hash":"cfbd2c121c5b3c583763d5f31fdf6cc169f0b3ff","id":"numpy.polynomial.hermite","ignore_all":true,"interface_hash":"c82cfc00c2b9be9c1433c9c81923bc44be9f1f3a","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/polynomial/hermite.pyi","plugin_data":null,"size":2463,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/hermite_e.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/hermite_e.data.json new file mode 100644 index 0000000000000000000000000000000000000000..eac35476a8d1b213c1c7df41ade11974aa19923b --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/hermite_e.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.polynomial.hermite_e","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","ABCPolyBase":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polybase.ABCPolyBase","kind":"Gdef","module_hidden":true,"module_public":false},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"Final":{".class":"SymbolTableNode","cross_ref":"typing.Final","kind":"Gdef","module_hidden":true,"module_public":false},"HermiteE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"He"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.polynomial.hermite_e.HermiteE","name":"HermiteE","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.polynomial.hermite_e.HermiteE","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.polynomial.hermite_e","mro":["numpy.polynomial.hermite_e.HermiteE","numpy.polynomial._polybase.ABCPolyBase","abc.ABC","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial.hermite_e.HermiteE.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.polynomial.hermite_e.HermiteE","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"L":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"_Array1":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._Array1","kind":"Gdef","module_hidden":true,"module_public":false},"_Array2":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._Array2","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncBinOp":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncBinOp","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncCompanion":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncCompanion","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncDer":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncDer","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncFit":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncFit","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncFromRoots":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncFromRoots","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncGauss":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncGauss","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncInteg":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncInteg","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncLine":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncLine","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncPoly2Ortho":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncPoly2Ortho","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncPow":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncPow","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncRoots":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncRoots","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncUnOp":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncUnOp","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVal":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVal","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVal2D":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVal2D","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVal3D":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVal3D","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncValFromRoots":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncValFromRoots","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVander":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVander","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVander2D":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVander2D","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVander3D":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVander3D","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncWeight":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncWeight","kind":"Gdef","module_hidden":true,"module_public":false},"_ND":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial.hermite_e._ND","name":"_ND","upper_bound":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"values":[],"variance":0}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.polynomial.hermite_e.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite_e.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite_e.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite_e.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite_e.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite_e.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite_e.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_normed_hermite_e_n":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x","n"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.polynomial.hermite_e._normed_hermite_e_n","name":"_normed_hermite_e_n","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x","n"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial.hermite_e._ND","id":-1,"name":"_ND","namespace":"numpy.polynomial.hermite_e._normed_hermite_e_n","upper_bound":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"values":[],"variance":0},{".class":"Instance","args":["numpy.float64"],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},{".class":"UnionType","items":["builtins.int",{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_normed_hermite_e_n","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial.hermite_e._ND","id":-1,"name":"_ND","namespace":"numpy.polynomial.hermite_e._normed_hermite_e_n","upper_bound":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"values":[],"variance":0},{".class":"Instance","args":["numpy.float64"],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial.hermite_e._ND","id":-1,"name":"_ND","namespace":"numpy.polynomial.hermite_e._normed_hermite_e_n","upper_bound":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"values":[],"variance":0}]}}},"herme2poly":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite_e.herme2poly","name":"herme2poly","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"herme2poly"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncUnOp"}}},"hermeadd":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite_e.hermeadd","name":"hermeadd","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermeadd"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"}}},"hermecompanion":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite_e.hermecompanion","name":"hermecompanion","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermecompanion"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncCompanion"}}},"hermeder":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite_e.hermeder","name":"hermeder","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermeder"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncDer"}}},"hermediv":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite_e.hermediv","name":"hermediv","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermediv"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"}}},"hermedomain":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy.polynomial.hermite_e.hermedomain","name":"hermedomain","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"hermefit":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite_e.hermefit","name":"hermefit","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermefit"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFit"}}},"hermefromroots":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite_e.hermefromroots","name":"hermefromroots","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermefromroots"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFromRoots"}}},"hermegauss":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite_e.hermegauss","name":"hermegauss","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermegauss"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncGauss"}}},"hermegrid2d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite_e.hermegrid2d","name":"hermegrid2d","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermegrid2d"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal2D"}}},"hermegrid3d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite_e.hermegrid3d","name":"hermegrid3d","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermegrid3d"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal3D"}}},"hermeint":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite_e.hermeint","name":"hermeint","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermeint"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncInteg"}}},"hermeline":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite_e.hermeline","name":"hermeline","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermeline"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncLine"}}},"hermemul":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite_e.hermemul","name":"hermemul","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermemul"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"}}},"hermemulx":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite_e.hermemulx","name":"hermemulx","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermemulx"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncUnOp"}}},"hermeone":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy.polynomial.hermite_e.hermeone","name":"hermeone","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"hermepow":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite_e.hermepow","name":"hermepow","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermepow"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncPow"}}},"hermeroots":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite_e.hermeroots","name":"hermeroots","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermeroots"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncRoots"}}},"hermesub":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite_e.hermesub","name":"hermesub","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermesub"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"}}},"hermetrim":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial.polyutils.trimcoef","kind":"Gdef"},"hermeval":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite_e.hermeval","name":"hermeval","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermeval"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal"}}},"hermeval2d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite_e.hermeval2d","name":"hermeval2d","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermeval2d"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal2D"}}},"hermeval3d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite_e.hermeval3d","name":"hermeval3d","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermeval3d"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal3D"}}},"hermevalfromroots":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite_e.hermevalfromroots","name":"hermevalfromroots","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermevalfromroots"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValFromRoots"}}},"hermevander":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite_e.hermevander","name":"hermevander","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermevander"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander"}}},"hermevander2d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite_e.hermevander2d","name":"hermevander2d","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermevander2d"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander2D"}}},"hermevander3d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite_e.hermevander3d","name":"hermevander3d","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermevander3d"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander3D"}}},"hermeweight":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite_e.hermeweight","name":"hermeweight","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"hermeweight"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncWeight"}}},"hermex":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy.polynomial.hermite_e.hermex","name":"hermex","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"hermezero":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy.polynomial.hermite_e.hermezero","name":"hermezero","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"poly2herme":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.hermite_e.poly2herme","name":"poly2herme","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"poly2herme"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncPoly2Ortho"}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/polynomial/hermite_e.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/hermite_e.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/hermite_e.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..29976df13c49c7b0edb6261d99ab93dce363124f --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/hermite_e.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[6,7,31,1,4,1,1,1],"dep_prios":[5,5,5,5,10,5,30,30],"dependencies":["numpy.polynomial._polybase","numpy.polynomial._polytypes","numpy.polynomial.polyutils","typing","numpy","builtins","_frozen_importlib","abc"],"hash":"67107a96652d71c2684e72e55941bb1b25bfa136","id":"numpy.polynomial.hermite_e","ignore_all":true,"interface_hash":"56009e6226302047a11b251a85de75ee58f0fc8b","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/polynomial/hermite_e.pyi","plugin_data":null,"size":2555,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/laguerre.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/laguerre.data.json new file mode 100644 index 0000000000000000000000000000000000000000..04ee4d1abe4c73c2a598b410df9bf16d48c49101 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/laguerre.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.polynomial.laguerre","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","ABCPolyBase":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polybase.ABCPolyBase","kind":"Gdef","module_hidden":true,"module_public":false},"Final":{".class":"SymbolTableNode","cross_ref":"typing.Final","kind":"Gdef","module_hidden":true,"module_public":false},"L":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"Laguerre":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"L"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.polynomial.laguerre.Laguerre","name":"Laguerre","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.polynomial.laguerre.Laguerre","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.polynomial.laguerre","mro":["numpy.polynomial.laguerre.Laguerre","numpy.polynomial._polybase.ABCPolyBase","abc.ABC","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial.laguerre.Laguerre.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.polynomial.laguerre.Laguerre","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_Array1":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._Array1","kind":"Gdef","module_hidden":true,"module_public":false},"_Array2":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._Array2","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncBinOp":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncBinOp","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncCompanion":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncCompanion","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncDer":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncDer","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncFit":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncFit","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncFromRoots":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncFromRoots","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncGauss":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncGauss","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncInteg":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncInteg","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncLine":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncLine","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncPoly2Ortho":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncPoly2Ortho","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncPow":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncPow","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncRoots":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncRoots","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncUnOp":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncUnOp","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVal":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVal","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVal2D":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVal2D","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVal3D":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVal3D","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncValFromRoots":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncValFromRoots","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVander":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVander","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVander2D":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVander2D","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVander3D":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVander3D","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncWeight":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncWeight","kind":"Gdef","module_hidden":true,"module_public":false},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.polynomial.laguerre.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.laguerre.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.laguerre.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.laguerre.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.laguerre.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.laguerre.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.laguerre.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"lag2poly":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.laguerre.lag2poly","name":"lag2poly","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"lag2poly"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncUnOp"}}},"lagadd":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.laguerre.lagadd","name":"lagadd","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"lagadd"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"}}},"lagcompanion":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.laguerre.lagcompanion","name":"lagcompanion","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"lagcompanion"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncCompanion"}}},"lagder":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.laguerre.lagder","name":"lagder","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"lagder"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncDer"}}},"lagdiv":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.laguerre.lagdiv","name":"lagdiv","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"lagdiv"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"}}},"lagdomain":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy.polynomial.laguerre.lagdomain","name":"lagdomain","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"lagfit":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.laguerre.lagfit","name":"lagfit","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"lagfit"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFit"}}},"lagfromroots":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.laguerre.lagfromroots","name":"lagfromroots","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"lagfromroots"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFromRoots"}}},"laggauss":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.laguerre.laggauss","name":"laggauss","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"laggauss"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncGauss"}}},"laggrid2d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.laguerre.laggrid2d","name":"laggrid2d","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"laggrid2d"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal2D"}}},"laggrid3d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.laguerre.laggrid3d","name":"laggrid3d","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"laggrid3d"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal3D"}}},"lagint":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.laguerre.lagint","name":"lagint","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"lagint"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncInteg"}}},"lagline":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.laguerre.lagline","name":"lagline","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"lagline"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncLine"}}},"lagmul":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.laguerre.lagmul","name":"lagmul","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"lagmul"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"}}},"lagmulx":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.laguerre.lagmulx","name":"lagmulx","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"lagmulx"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncUnOp"}}},"lagone":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy.polynomial.laguerre.lagone","name":"lagone","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"lagpow":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.laguerre.lagpow","name":"lagpow","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"lagpow"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncPow"}}},"lagroots":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.laguerre.lagroots","name":"lagroots","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"lagroots"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncRoots"}}},"lagsub":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.laguerre.lagsub","name":"lagsub","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"lagsub"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"}}},"lagtrim":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial.polyutils.trimcoef","kind":"Gdef"},"lagval":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.laguerre.lagval","name":"lagval","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"lagval"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal"}}},"lagval2d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.laguerre.lagval2d","name":"lagval2d","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"lagval2d"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal2D"}}},"lagval3d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.laguerre.lagval3d","name":"lagval3d","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"lagval3d"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal3D"}}},"lagvalfromroots":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.laguerre.lagvalfromroots","name":"lagvalfromroots","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"lagvalfromroots"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValFromRoots"}}},"lagvander":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.laguerre.lagvander","name":"lagvander","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"lagvander"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander"}}},"lagvander2d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.laguerre.lagvander2d","name":"lagvander2d","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"lagvander2d"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander2D"}}},"lagvander3d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.laguerre.lagvander3d","name":"lagvander3d","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"lagvander3d"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander3D"}}},"lagweight":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.laguerre.lagweight","name":"lagweight","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"lagweight"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncWeight"}}},"lagx":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy.polynomial.laguerre.lagx","name":"lagx","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"lagzero":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy.polynomial.laguerre.lagzero","name":"lagzero","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"poly2lag":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.laguerre.poly2lag","name":"poly2lag","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"poly2lag"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncPoly2Ortho"}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/polynomial/laguerre.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/laguerre.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/laguerre.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..5acb3a7b98913c0fe942d03f93e2ecf8ba215bd8 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/laguerre.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[6,7,31,1,4,1,1,1],"dep_prios":[5,5,5,5,10,5,30,30],"dependencies":["numpy.polynomial._polybase","numpy.polynomial._polytypes","numpy.polynomial.polyutils","typing","numpy","builtins","_frozen_importlib","abc"],"hash":"9b3d7fac9210b651d6c1cb62cd2374c71fbf36d4","id":"numpy.polynomial.laguerre","ignore_all":true,"interface_hash":"001d014ee0c5bf53888e3f5e4a2dee4124e431bf","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/polynomial/laguerre.pyi","plugin_data":null,"size":2191,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/legendre.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/legendre.data.json new file mode 100644 index 0000000000000000000000000000000000000000..a1ea3f853ffebf1d94b43342ad995fa96948fc5a --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/legendre.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.polynomial.legendre","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","ABCPolyBase":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polybase.ABCPolyBase","kind":"Gdef","module_hidden":true,"module_public":false},"Final":{".class":"SymbolTableNode","cross_ref":"typing.Final","kind":"Gdef","module_hidden":true,"module_public":false},"L":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"Legendre":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"P"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.polynomial.legendre.Legendre","name":"Legendre","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.polynomial.legendre.Legendre","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.polynomial.legendre","mro":["numpy.polynomial.legendre.Legendre","numpy.polynomial._polybase.ABCPolyBase","abc.ABC","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial.legendre.Legendre.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.polynomial.legendre.Legendre","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_Array1":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._Array1","kind":"Gdef","module_hidden":true,"module_public":false},"_Array2":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._Array2","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncBinOp":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncBinOp","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncCompanion":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncCompanion","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncDer":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncDer","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncFit":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncFit","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncFromRoots":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncFromRoots","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncGauss":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncGauss","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncInteg":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncInteg","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncLine":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncLine","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncPoly2Ortho":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncPoly2Ortho","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncPow":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncPow","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncRoots":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncRoots","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncUnOp":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncUnOp","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVal":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVal","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVal2D":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVal2D","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVal3D":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVal3D","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncValFromRoots":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncValFromRoots","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVander":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVander","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVander2D":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVander2D","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVander3D":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVander3D","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncWeight":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncWeight","kind":"Gdef","module_hidden":true,"module_public":false},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.polynomial.legendre.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.legendre.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.legendre.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.legendre.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.legendre.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.legendre.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.legendre.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"leg2poly":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.legendre.leg2poly","name":"leg2poly","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"leg2poly"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncUnOp"}}},"legadd":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.legendre.legadd","name":"legadd","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"legadd"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"}}},"legcompanion":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.legendre.legcompanion","name":"legcompanion","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"legcompanion"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncCompanion"}}},"legder":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.legendre.legder","name":"legder","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"legder"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncDer"}}},"legdiv":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.legendre.legdiv","name":"legdiv","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"legdiv"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"}}},"legdomain":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy.polynomial.legendre.legdomain","name":"legdomain","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"legfit":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.legendre.legfit","name":"legfit","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"legfit"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFit"}}},"legfromroots":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.legendre.legfromroots","name":"legfromroots","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"legfromroots"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFromRoots"}}},"leggauss":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.legendre.leggauss","name":"leggauss","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"leggauss"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncGauss"}}},"leggrid2d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.legendre.leggrid2d","name":"leggrid2d","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"leggrid2d"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal2D"}}},"leggrid3d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.legendre.leggrid3d","name":"leggrid3d","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"leggrid3d"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal3D"}}},"legint":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.legendre.legint","name":"legint","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"legint"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncInteg"}}},"legline":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.legendre.legline","name":"legline","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"legline"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncLine"}}},"legmul":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.legendre.legmul","name":"legmul","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"legmul"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"}}},"legmulx":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.legendre.legmulx","name":"legmulx","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"legmulx"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncUnOp"}}},"legone":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy.polynomial.legendre.legone","name":"legone","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"legpow":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.legendre.legpow","name":"legpow","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"legpow"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncPow"}}},"legroots":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.legendre.legroots","name":"legroots","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"legroots"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncRoots"}}},"legsub":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.legendre.legsub","name":"legsub","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"legsub"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"}}},"legtrim":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial.polyutils.trimcoef","kind":"Gdef"},"legval":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.legendre.legval","name":"legval","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"legval"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal"}}},"legval2d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.legendre.legval2d","name":"legval2d","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"legval2d"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal2D"}}},"legval3d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.legendre.legval3d","name":"legval3d","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"legval3d"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal3D"}}},"legvalfromroots":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.legendre.legvalfromroots","name":"legvalfromroots","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"legvalfromroots"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValFromRoots"}}},"legvander":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.legendre.legvander","name":"legvander","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"legvander"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander"}}},"legvander2d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.legendre.legvander2d","name":"legvander2d","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"legvander2d"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander2D"}}},"legvander3d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.legendre.legvander3d","name":"legvander3d","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"legvander3d"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander3D"}}},"legweight":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.legendre.legweight","name":"legweight","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"legweight"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncWeight"}}},"legx":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy.polynomial.legendre.legx","name":"legx","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"legzero":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy.polynomial.legendre.legzero","name":"legzero","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"poly2leg":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.legendre.poly2leg","name":"poly2leg","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"poly2leg"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncPoly2Ortho"}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/polynomial/legendre.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/legendre.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/legendre.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..f2a7e6aea88458175a0e8e9be99c23bbf6b146e4 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/legendre.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[6,7,31,1,4,1,1,1],"dep_prios":[5,5,5,5,10,5,30,30],"dependencies":["numpy.polynomial._polybase","numpy.polynomial._polytypes","numpy.polynomial.polyutils","typing","numpy","builtins","_frozen_importlib","abc"],"hash":"48eb9a9df90639db14be31b1da88801cef026eff","id":"numpy.polynomial.legendre","ignore_all":true,"interface_hash":"f16de0e2728d5bbc837eac5d302739c49d784fc8","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/polynomial/legendre.pyi","plugin_data":null,"size":2191,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/polynomial.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/polynomial.data.json new file mode 100644 index 0000000000000000000000000000000000000000..eeacfa067c0c1ce82ff5ffa17683f3dbfa165dc1 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/polynomial.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.polynomial.polynomial","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","ABCPolyBase":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polybase.ABCPolyBase","kind":"Gdef","module_hidden":true,"module_public":false},"Final":{".class":"SymbolTableNode","cross_ref":"typing.Final","kind":"Gdef","module_hidden":true,"module_public":false},"L":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"Polynomial":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"NoneType"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polybase.ABCPolyBase"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.polynomial.polynomial.Polynomial","name":"Polynomial","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.polynomial.polynomial.Polynomial","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.polynomial.polynomial","mro":["numpy.polynomial.polynomial.Polynomial","numpy.polynomial._polybase.ABCPolyBase","abc.ABC","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial.polynomial.Polynomial.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.polynomial.polynomial.Polynomial","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_Array1":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._Array1","kind":"Gdef","module_hidden":true,"module_public":false},"_Array2":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._Array2","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncBinOp":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncBinOp","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncCompanion":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncCompanion","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncDer":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncDer","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncFit":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncFit","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncFromRoots":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncFromRoots","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncInteg":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncInteg","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncLine":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncLine","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncPow":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncPow","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncRoots":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncRoots","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncUnOp":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncUnOp","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVal":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVal","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVal2D":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVal2D","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVal3D":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVal3D","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncValFromRoots":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncValFromRoots","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVander":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVander","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVander2D":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVander2D","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVander3D":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVander3D","kind":"Gdef","module_hidden":true,"module_public":false},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.polynomial.polynomial.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polynomial.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polynomial.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polynomial.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polynomial.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polynomial.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polynomial.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"polyadd":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polynomial.polyadd","name":"polyadd","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"polyadd"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"}}},"polycompanion":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polynomial.polycompanion","name":"polycompanion","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"polycompanion"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncCompanion"}}},"polyder":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polynomial.polyder","name":"polyder","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"polyder"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncDer"}}},"polydiv":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polynomial.polydiv","name":"polydiv","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"polydiv"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"}}},"polydomain":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy.polynomial.polynomial.polydomain","name":"polydomain","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"polyfit":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polynomial.polyfit","name":"polyfit","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"polyfit"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFit"}}},"polyfromroots":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polynomial.polyfromroots","name":"polyfromroots","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"polyfromroots"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncFromRoots"}}},"polygrid2d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polynomial.polygrid2d","name":"polygrid2d","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"polygrid2d"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal2D"}}},"polygrid3d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polynomial.polygrid3d","name":"polygrid3d","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"polygrid3d"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal3D"}}},"polyint":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polynomial.polyint","name":"polyint","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"polyint"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncInteg"}}},"polyline":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polynomial.polyline","name":"polyline","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"Polyline"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncLine"}}},"polymul":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polynomial.polymul","name":"polymul","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"polymul"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"}}},"polymulx":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polynomial.polymulx","name":"polymulx","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"polymulx"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncUnOp"}}},"polyone":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy.polynomial.polynomial.polyone","name":"polyone","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"polypow":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polynomial.polypow","name":"polypow","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"polypow"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncPow"}}},"polyroots":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polynomial.polyroots","name":"polyroots","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"polyroots"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncRoots"}}},"polysub":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polynomial.polysub","name":"polysub","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"polysub"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"}}},"polytrim":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial.polyutils.trimcoef","kind":"Gdef"},"polyval":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polynomial.polyval","name":"polyval","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"polyval"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal"}}},"polyval2d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polynomial.polyval2d","name":"polyval2d","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"polyval2d"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal2D"}}},"polyval3d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polynomial.polyval3d","name":"polyval3d","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"polyval3d"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVal3D"}}},"polyvalfromroots":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polynomial.polyvalfromroots","name":"polyvalfromroots","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"polyvalfromroots"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValFromRoots"}}},"polyvander":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polynomial.polyvander","name":"polyvander","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"polyvander"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander"}}},"polyvander2d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polynomial.polyvander2d","name":"polyvander2d","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"polyvander2d"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander2D"}}},"polyvander3d":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polynomial.polyvander3d","name":"polyvander3d","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"polyvander3d"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVander3D"}}},"polyx":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy.polynomial.polynomial.polyx","name":"polyx","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}},"polyzero":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy.polynomial.polynomial.polyzero","name":"polyzero","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/polynomial/polynomial.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/polynomial.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/polynomial.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..85a1092004170391fa2a9f64a9f813e9ba256cf4 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/polynomial.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[6,7,28,1,4,1,1,1],"dep_prios":[5,5,5,5,10,5,30,30],"dependencies":["numpy.polynomial._polybase","numpy.polynomial._polytypes","numpy.polynomial.polyutils","typing","numpy","builtins","_frozen_importlib","abc"],"hash":"635ee3056489cd787590f4d2a5b31a3ed9b0a199","id":"numpy.polynomial.polynomial","ignore_all":true,"interface_hash":"8c8c08bc4141ff4afc67fa123c3dfd9f646663a1","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/polynomial/polynomial.pyi","plugin_data":null,"size":2021,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/polyutils.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/polyutils.data.json new file mode 100644 index 0000000000000000000000000000000000000000..297d2a60299af980030456cf99e5c2d659cd03e8 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/polyutils.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.polynomial.polyutils","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef","module_hidden":true,"module_public":false},"Final":{".class":"SymbolTableNode","cross_ref":"typing.Final","kind":"Gdef","module_hidden":true,"module_public":false},"Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef","module_hidden":true,"module_public":false},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef","module_hidden":true,"module_public":false},"SupportsIndex":{".class":"SymbolTableNode","cross_ref":"typing.SupportsIndex","kind":"Gdef","module_hidden":true,"module_public":false},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3}}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"_AnyInt":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._AnyInt","kind":"Gdef","module_hidden":true,"module_public":false},"_AnyLineF":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.polynomial.polyutils._AnyLineF","name":"_AnyLineF","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3}}},"_AnyMulF":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.polynomial.polyutils._AnyMulF","name":"_AnyMulF","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3}}},"_AnyVanderF":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.polynomial.polyutils._AnyVanderF","name":"_AnyVanderF","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3}}},"_Array2":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._Array2","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeCoef_co":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._ArrayLikeCoef_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeComplex_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeComplex_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeFloat_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeFloat_co","kind":"Gdef","module_hidden":true,"module_public":false},"_CoefArray":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._CoefArray","kind":"Gdef","module_hidden":true,"module_public":false},"_CoefLike_co":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._CoefLike_co","kind":"Gdef","module_hidden":true,"module_public":false},"_CoefSeries":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._CoefSeries","kind":"Gdef","module_hidden":true,"module_public":false},"_ComplexArray":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._ComplexArray","kind":"Gdef","module_hidden":true,"module_public":false},"_ComplexSeries":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._ComplexSeries","kind":"Gdef","module_hidden":true,"module_public":false},"_FloatArray":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FloatArray","kind":"Gdef","module_hidden":true,"module_public":false},"_FloatLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._FloatLike_co","kind":"Gdef","module_hidden":true,"module_public":false},"_FloatSeries":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FloatSeries","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncBinOp":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncBinOp","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncValND":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncValND","kind":"Gdef","module_hidden":true,"module_public":false},"_FuncVanderND":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._FuncVanderND","kind":"Gdef","module_hidden":true,"module_public":false},"_NumberLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._NumberLike_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ObjectArray":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._ObjectArray","kind":"Gdef","module_hidden":true,"module_public":false},"_ObjectSeries":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._ObjectSeries","kind":"Gdef","module_hidden":true,"module_public":false},"_SeriesLikeCoef_co":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._SeriesLikeCoef_co","kind":"Gdef","module_hidden":true,"module_public":false},"_SeriesLikeComplex_co":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._SeriesLikeComplex_co","kind":"Gdef","module_hidden":true,"module_public":false},"_SeriesLikeFloat_co":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._SeriesLikeFloat_co","kind":"Gdef","module_hidden":true,"module_public":false},"_SeriesLikeInt_co":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._SeriesLikeInt_co","kind":"Gdef","module_hidden":true,"module_public":false},"_T_seq":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial.polyutils._T_seq","name":"_T_seq","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},"values":[],"variance":0}},"_Tuple2":{".class":"SymbolTableNode","cross_ref":"numpy.polynomial._polytypes._Tuple2","kind":"Gdef","module_hidden":true,"module_public":false},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.polynomial.polyutils.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polyutils.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polyutils.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polyutils.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polyutils.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polyutils.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polyutils.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_add":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy.polynomial.polyutils._add","name":"_add","setter_type":null,"type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"}}},"_as_int":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x","desc"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.polynomial.polyutils._as_int","name":"_as_int","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x","desc"],"arg_types":["typing.SupportsIndex","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_as_int","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_div":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.polynomial.polyutils._div","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["mul_f","c1","c2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils._div","name":"_div","original_first_arg":"mul_f","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["mul_f","c1","c2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_div","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils._div","name":"_div","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["mul_f","c1","c2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_div","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["mul_f","c1","c2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils._div","name":"_div","original_first_arg":"mul_f","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["mul_f","c1","c2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_div","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils._div","name":"_div","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["mul_f","c1","c2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_div","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["mul_f","c1","c2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils._div","name":"_div","original_first_arg":"mul_f","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["mul_f","c1","c2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_div","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils._div","name":"_div","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["mul_f","c1","c2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_div","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["mul_f","c1","c2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils._div","name":"_div","original_first_arg":"mul_f","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["mul_f","c1","c2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_div","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils._div","name":"_div","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["mul_f","c1","c2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_div","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["mul_f","c1","c2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_div","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["mul_f","c1","c2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_div","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["mul_f","c1","c2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_div","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["mul_f","c1","c2"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_div","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"_fit":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.polynomial.polyutils._fit","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1,1,1,1],"arg_names":["vander_f","x","y","deg","domain","rcond","full","w"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils._fit","name":"_fit","original_first_arg":"vander_f","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1,1],"arg_names":["vander_f","x","y","deg","domain","rcond","full","w"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_fit","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils._fit","name":"_fit","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1,1],"arg_names":["vander_f","x","y","deg","domain","rcond","full","w"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_fit","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1,1,1,1],"arg_names":["vander_f","x","y","deg","domain","rcond","full","w"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils._fit","name":"_fit","original_first_arg":"vander_f","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1,1],"arg_names":["vander_f","x","y","deg","domain","rcond","full","w"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_fit","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils._fit","name":"_fit","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1,1],"arg_names":["vander_f","x","y","deg","domain","rcond","full","w"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_fit","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1,1,1,1],"arg_names":["vander_f","x","y","deg","domain","rcond","full","w"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils._fit","name":"_fit","original_first_arg":"vander_f","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1,1],"arg_names":["vander_f","x","y","deg","domain","rcond","full","w"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_fit","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils._fit","name":"_fit","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1,1],"arg_names":["vander_f","x","y","deg","domain","rcond","full","w"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_fit","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0,0,0,1],"arg_names":[null,null,null,null,null,null,null,"w"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils._fit","name":"_fit","original_first_arg":"vander_f","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,0,1],"arg_names":[null,null,null,null,null,null,null,"w"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_fit","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.inexact"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils._fit","name":"_fit","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,0,1],"arg_names":[null,null,null,null,null,null,null,"w"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_fit","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.inexact"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1,1,3,5],"arg_names":["vander_f","x","y","deg","domain","rcond","full","w"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils._fit","name":"_fit","original_first_arg":"vander_f","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,3,5],"arg_names":["vander_f","x","y","deg","domain","rcond","full","w"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_fit","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.inexact"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils._fit","name":"_fit","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,3,5],"arg_names":["vander_f","x","y","deg","domain","rcond","full","w"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_fit","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.inexact"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1,1],"arg_names":["vander_f","x","y","deg","domain","rcond","full","w"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_fit","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1,1],"arg_names":["vander_f","x","y","deg","domain","rcond","full","w"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_fit","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1,1],"arg_names":["vander_f","x","y","deg","domain","rcond","full","w"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_fit","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,0,1],"arg_names":[null,null,null,null,null,null,null,"w"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_fit","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.inexact"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,3,5],"arg_names":["vander_f","x","y","deg","domain","rcond","full","w"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_fit","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.float","builtins.complex"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.inexact"},{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"_fromroots":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.polynomial.polyutils._fromroots","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["line_f","mul_f","roots"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils._fromroots","name":"_fromroots","original_first_arg":"line_f","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["line_f","mul_f","roots"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_fromroots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils._fromroots","name":"_fromroots","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["line_f","mul_f","roots"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_fromroots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["line_f","mul_f","roots"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils._fromroots","name":"_fromroots","original_first_arg":"line_f","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["line_f","mul_f","roots"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_fromroots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils._fromroots","name":"_fromroots","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["line_f","mul_f","roots"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_fromroots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["line_f","mul_f","roots"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils._fromroots","name":"_fromroots","original_first_arg":"line_f","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["line_f","mul_f","roots"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_fromroots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils._fromroots","name":"_fromroots","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["line_f","mul_f","roots"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_fromroots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["line_f","mul_f","roots"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils._fromroots","name":"_fromroots","original_first_arg":"line_f","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["line_f","mul_f","roots"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_fromroots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils._fromroots","name":"_fromroots","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["line_f","mul_f","roots"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_fromroots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["line_f","mul_f","roots"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_fromroots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["line_f","mul_f","roots"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_fromroots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["line_f","mul_f","roots"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_fromroots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["line_f","mul_f","roots"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_fromroots","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"_gridnd":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polyutils._gridnd","name":"_gridnd","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"_gridnd"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValND"}}},"_nth_slice":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["i","ndim"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.polynomial.polyutils._nth_slice","name":"_nth_slice","original_first_arg":"i","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["i","ndim"],"arg_types":["typing.SupportsIndex","typing.SupportsIndex"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_nth_slice","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.slice"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_pow":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.polynomial.polyutils._pow","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["mul_f","c","pow","maxpower"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils._pow","name":"_pow","original_first_arg":"mul_f","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["mul_f","c","pow","maxpower"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_pow","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils._pow","name":"_pow","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["mul_f","c","pow","maxpower"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_pow","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["mul_f","c","pow","maxpower"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils._pow","name":"_pow","original_first_arg":"mul_f","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["mul_f","c","pow","maxpower"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_pow","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils._pow","name":"_pow","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["mul_f","c","pow","maxpower"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_pow","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["mul_f","c","pow","maxpower"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils._pow","name":"_pow","original_first_arg":"mul_f","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["mul_f","c","pow","maxpower"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_pow","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils._pow","name":"_pow","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["mul_f","c","pow","maxpower"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_pow","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["mul_f","c","pow","maxpower"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils._pow","name":"_pow","original_first_arg":"mul_f","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["mul_f","c","pow","maxpower"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_pow","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils._pow","name":"_pow","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["mul_f","c","pow","maxpower"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_pow","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["mul_f","c","pow","maxpower"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_pow","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["mul_f","c","pow","maxpower"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_pow","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["mul_f","c","pow","maxpower"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_pow","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["mul_f","c","pow","maxpower"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial.polyutils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_pow","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"_sub":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_final","is_ready"],"fullname":"numpy.polynomial.polyutils._sub","name":"_sub","setter_type":null,"type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.LiteralString","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncBinOp"}}},"_valnd":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polyutils._valnd","name":"_valnd","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"_valnd"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncValND"}}},"_vander_nd":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polyutils._vander_nd","name":"_vander_nd","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"_vander_nd"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVanderND"}}},"_vander_nd_flat":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.polynomial.polyutils._vander_nd_flat","name":"_vander_nd_flat","setter_type":null,"type":{".class":"Instance","args":[{".class":"LiteralType","fallback":"builtins.str","value":"_vander_nd_flat"}],"extra_attrs":null,"type_ref":"numpy.polynomial._polytypes._FuncVanderND"}}},"as_series":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.polynomial.polyutils.as_series","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["alist","trim"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.as_series","name":"as_series","original_first_arg":"alist","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["alist","trim"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_series","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.as_series","name":"as_series","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["alist","trim"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_series","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["alist","trim"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.as_series","name":"as_series","original_first_arg":"alist","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["alist","trim"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_series","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.as_series","name":"as_series","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["alist","trim"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_series","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["alist","trim"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.as_series","name":"as_series","original_first_arg":"alist","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["alist","trim"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_series","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.as_series","name":"as_series","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["alist","trim"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_series","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["alist","trim"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.as_series","name":"as_series","original_first_arg":"alist","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["alist","trim"],"arg_types":[{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_series","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.as_series","name":"as_series","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["alist","trim"],"arg_types":[{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_series","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["alist","trim"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.as_series","name":"as_series","original_first_arg":"alist","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["alist","trim"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_series","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.as_series","name":"as_series","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["alist","trim"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_series","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["alist","trim"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.as_series","name":"as_series","original_first_arg":"alist","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["alist","trim"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_series","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.as_series","name":"as_series","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["alist","trim"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_series","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["alist","trim"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.as_series","name":"as_series","original_first_arg":"alist","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["alist","trim"],"arg_types":[{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.float"],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_series","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.as_series","name":"as_series","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["alist","trim"],"arg_types":[{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.float"],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_series","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["alist","trim"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.as_series","name":"as_series","original_first_arg":"alist","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["alist","trim"],"arg_types":[{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.complex"],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_series","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.as_series","name":"as_series","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["alist","trim"],"arg_types":[{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.complex"],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_series","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["alist","trim"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.as_series","name":"as_series","original_first_arg":"alist","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["alist","trim"],"arg_types":[{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.object"],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_series","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.as_series","name":"as_series","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["alist","trim"],"arg_types":[{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.object"],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_series","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["alist","trim"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_series","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["alist","trim"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_series","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["alist","trim"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_series","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["alist","trim"],"arg_types":[{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_series","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["alist","trim"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_series","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["alist","trim"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_series","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["alist","trim"],"arg_types":[{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.float"],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_series","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["alist","trim"],"arg_types":[{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.complex"],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_series","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["alist","trim"],"arg_types":[{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.object"],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_series","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"format_float":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["x","parens"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.polynomial.polyutils.format_float","name":"format_float","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["x","parens"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"format_float","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"getdomain":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.polynomial.polyutils.getdomain","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.getdomain","name":"getdomain","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getdomain","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.getdomain","name":"getdomain","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getdomain","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.getdomain","name":"getdomain","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getdomain","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.getdomain","name":"getdomain","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getdomain","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.getdomain","name":"getdomain","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getdomain","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.getdomain","name":"getdomain","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getdomain","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.getdomain","name":"getdomain","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.float"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getdomain","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.getdomain","name":"getdomain","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.float"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getdomain","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.getdomain","name":"getdomain","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.complex"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getdomain","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.getdomain","name":"getdomain","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.complex"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getdomain","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.getdomain","name":"getdomain","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.object"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getdomain","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.getdomain","name":"getdomain","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.object"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getdomain","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getdomain","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getdomain","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getdomain","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.float"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getdomain","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.complex"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getdomain","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.object"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getdomain","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"mapdomain":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.polynomial.polyutils.mapdomain","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["x","old","new"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.mapdomain","name":"mapdomain","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["x","old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapdomain","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.mapdomain","name":"mapdomain","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["x","old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapdomain","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["x","old","new"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.mapdomain","name":"mapdomain","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["x","old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapdomain","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.mapdomain","name":"mapdomain","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["x","old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapdomain","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["x","old","new"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.mapdomain","name":"mapdomain","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["x","old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapdomain","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.mapdomain","name":"mapdomain","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["x","old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapdomain","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["x","old","new"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.mapdomain","name":"mapdomain","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["x","old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapdomain","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.mapdomain","name":"mapdomain","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["x","old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapdomain","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["x","old","new"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.mapdomain","name":"mapdomain","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["x","old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapdomain","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.mapdomain","name":"mapdomain","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["x","old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapdomain","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["x","old","new"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.mapdomain","name":"mapdomain","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["x","old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapdomain","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.mapdomain","name":"mapdomain","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["x","old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapdomain","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["x","old","new"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.mapdomain","name":"mapdomain","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["x","old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapdomain","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.mapdomain","name":"mapdomain","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["x","old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapdomain","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["x","old","new"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.mapdomain","name":"mapdomain","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["x","old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapdomain","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.mapdomain","name":"mapdomain","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["x","old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapdomain","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["x","old","new"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.mapdomain","name":"mapdomain","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["x","old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapdomain","ret_type":"builtins.object","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.mapdomain","name":"mapdomain","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["x","old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapdomain","ret_type":"builtins.object","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["x","old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapdomain","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.floating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["x","old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapdomain","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.complexfloating"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["x","old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapdomain","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["x","old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapdomain","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["x","old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapdomain","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["x","old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapdomain","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["x","old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapdomain","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["x","old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapdomain","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["x","old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapdomain","ret_type":"builtins.object","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"mapparms":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.polynomial.polyutils.mapparms","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["old","new"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.mapparms","name":"mapparms","original_first_arg":"old","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapparms","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.mapparms","name":"mapparms","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapparms","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["old","new"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.mapparms","name":"mapparms","original_first_arg":"old","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapparms","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.mapparms","name":"mapparms","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapparms","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["old","new"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.mapparms","name":"mapparms","original_first_arg":"old","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapparms","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.mapparms","name":"mapparms","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapparms","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["old","new"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.mapparms","name":"mapparms","original_first_arg":"old","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["old","new"],"arg_types":[{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapparms","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.mapparms","name":"mapparms","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["old","new"],"arg_types":[{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapparms","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["old","new"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.mapparms","name":"mapparms","original_first_arg":"old","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["old","new"],"arg_types":[{".class":"Instance","args":["builtins.complex"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":["builtins.complex"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapparms","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.mapparms","name":"mapparms","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["old","new"],"arg_types":[{".class":"Instance","args":["builtins.complex"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":["builtins.complex"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapparms","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["old","new"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.mapparms","name":"mapparms","original_first_arg":"old","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapparms","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.mapparms","name":"mapparms","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapparms","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["old","new"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.mapparms","name":"mapparms","original_first_arg":"old","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapparms","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.mapparms","name":"mapparms","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapparms","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["old","new"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.mapparms","name":"mapparms","original_first_arg":"old","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapparms","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.mapparms","name":"mapparms","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapparms","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapparms","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapparms","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapparms","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["old","new"],"arg_types":[{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapparms","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["old","new"],"arg_types":[{".class":"Instance","args":["builtins.complex"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"Instance","args":["builtins.complex"],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapparms","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapparms","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapparms","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["old","new"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mapparms","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"npt":{".class":"SymbolTableNode","cross_ref":"numpy.typing","kind":"Gdef","module_hidden":true,"module_public":false},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false},"trimcoef":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.polynomial.polyutils.trimcoef","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["c","tol"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.trimcoef","name":"trimcoef","original_first_arg":"c","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["c","tol"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trimcoef","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.trimcoef","name":"trimcoef","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["c","tol"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trimcoef","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["c","tol"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.trimcoef","name":"trimcoef","original_first_arg":"c","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["c","tol"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trimcoef","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.trimcoef","name":"trimcoef","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["c","tol"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trimcoef","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["c","tol"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.trimcoef","name":"trimcoef","original_first_arg":"c","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["c","tol"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trimcoef","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.trimcoef","name":"trimcoef","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["c","tol"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trimcoef","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["c","tol"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.trimcoef","name":"trimcoef","original_first_arg":"c","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["c","tol"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.float"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trimcoef","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.trimcoef","name":"trimcoef","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["c","tol"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.float"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trimcoef","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["c","tol"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.trimcoef","name":"trimcoef","original_first_arg":"c","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["c","tol"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.complex"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trimcoef","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.trimcoef","name":"trimcoef","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["c","tol"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.complex"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trimcoef","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["c","tol"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.polynomial.polyutils.trimcoef","name":"trimcoef","original_first_arg":"c","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["c","tol"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.object"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trimcoef","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.polynomial.polyutils.trimcoef","name":"trimcoef","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["c","tol"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.object"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trimcoef","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["c","tol"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trimcoef","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["c","tol"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trimcoef","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["c","tol"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trimcoef","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["c","tol"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.float"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trimcoef","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["c","tol"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.complex"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trimcoef","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["c","tol"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"builtins.object"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trimcoef","ret_type":{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"trimseq":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["seq"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.polynomial.polyutils.trimseq","name":"trimseq","original_first_arg":"seq","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["seq"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial.polyutils._T_seq","id":-1,"name":"_T_seq","namespace":"numpy.polynomial.polyutils.trimseq","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"trimseq","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial.polyutils._T_seq","id":-1,"name":"_T_seq","namespace":"numpy.polynomial.polyutils.trimseq","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.polynomial.polyutils._T_seq","id":-1,"name":"_T_seq","namespace":"numpy.polynomial.polyutils.trimseq","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.polynomial._polytypes.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"uses_pep604_syntax":true},"values":[],"variance":0}]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/polynomial/polyutils.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/polyutils.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/polyutils.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..1d6db6cc69496eb39bd01d122972237e49bbaabd --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/polynomial/polyutils.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[20,1,12,13,2,11,1,1,1,1],"dep_prios":[5,5,10,5,5,10,5,30,30,30],"dependencies":["numpy.polynomial._polytypes","collections.abc","numpy.typing","numpy._typing","typing","numpy","builtins","_frozen_importlib","abc","numpy._typing._nbit_base"],"hash":"69ebbb2002f97449776a28e02c41d3995f6ca341","id":"numpy.polynomial.polyutils","ignore_all":true,"interface_hash":"3c2b7f5b8f3167a9877bb21d1b2ca72d5d20a6b8","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/polynomial/polyutils.pyi","plugin_data":null,"size":10235,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..4865233ca05098c2cef13b41ae7e3e7d22fd66ac --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.random","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","BitGenerator":{".class":"SymbolTableNode","cross_ref":"numpy.random.bit_generator.BitGenerator","kind":"Gdef"},"Generator":{".class":"SymbolTableNode","cross_ref":"numpy.random._generator.Generator","kind":"Gdef"},"MT19937":{".class":"SymbolTableNode","cross_ref":"numpy.random._mt19937.MT19937","kind":"Gdef"},"PCG64":{".class":"SymbolTableNode","cross_ref":"numpy.random._pcg64.PCG64","kind":"Gdef"},"PCG64DXSM":{".class":"SymbolTableNode","cross_ref":"numpy.random._pcg64.PCG64DXSM","kind":"Gdef"},"Philox":{".class":"SymbolTableNode","cross_ref":"numpy.random._philox.Philox","kind":"Gdef"},"RandomState":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.RandomState","kind":"Gdef"},"SFC64":{".class":"SymbolTableNode","cross_ref":"numpy.random._sfc64.SFC64","kind":"Gdef"},"SeedSequence":{".class":"SymbolTableNode","cross_ref":"numpy.random.bit_generator.SeedSequence","kind":"Gdef"},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"beta":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.beta","kind":"Gdef"},"binomial":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.binomial","kind":"Gdef"},"bytes":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.bytes","kind":"Gdef"},"chisquare":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.chisquare","kind":"Gdef"},"choice":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.choice","kind":"Gdef"},"default_rng":{".class":"SymbolTableNode","cross_ref":"numpy.random._generator.default_rng","kind":"Gdef"},"dirichlet":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.dirichlet","kind":"Gdef"},"exponential":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.exponential","kind":"Gdef"},"f":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.f","kind":"Gdef"},"gamma":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.gamma","kind":"Gdef"},"geometric":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.geometric","kind":"Gdef"},"get_bit_generator":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.get_bit_generator","kind":"Gdef","module_hidden":true,"module_public":false},"get_state":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.get_state","kind":"Gdef"},"gumbel":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.gumbel","kind":"Gdef"},"hypergeometric":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.hypergeometric","kind":"Gdef"},"laplace":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.laplace","kind":"Gdef"},"logistic":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.logistic","kind":"Gdef"},"lognormal":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.lognormal","kind":"Gdef"},"logseries":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.logseries","kind":"Gdef"},"multinomial":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.multinomial","kind":"Gdef"},"multivariate_normal":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.multivariate_normal","kind":"Gdef"},"negative_binomial":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.negative_binomial","kind":"Gdef"},"noncentral_chisquare":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.noncentral_chisquare","kind":"Gdef"},"noncentral_f":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.noncentral_f","kind":"Gdef"},"normal":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.normal","kind":"Gdef"},"pareto":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.pareto","kind":"Gdef"},"permutation":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.permutation","kind":"Gdef"},"poisson":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.poisson","kind":"Gdef"},"power":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.power","kind":"Gdef"},"rand":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.rand","kind":"Gdef"},"randint":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.randint","kind":"Gdef"},"randn":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.randn","kind":"Gdef"},"random":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.random","kind":"Gdef"},"random_integers":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.random_integers","kind":"Gdef"},"random_sample":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.random_sample","kind":"Gdef"},"ranf":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.ranf","kind":"Gdef"},"rayleigh":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.rayleigh","kind":"Gdef"},"sample":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.sample","kind":"Gdef"},"seed":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.seed","kind":"Gdef"},"set_bit_generator":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.set_bit_generator","kind":"Gdef","module_hidden":true,"module_public":false},"set_state":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.set_state","kind":"Gdef"},"shuffle":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.shuffle","kind":"Gdef"},"standard_cauchy":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.standard_cauchy","kind":"Gdef"},"standard_exponential":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.standard_exponential","kind":"Gdef"},"standard_gamma":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.standard_gamma","kind":"Gdef"},"standard_normal":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.standard_normal","kind":"Gdef"},"standard_t":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.standard_t","kind":"Gdef"},"triangular":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.triangular","kind":"Gdef"},"uniform":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.uniform","kind":"Gdef"},"vonmises":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.vonmises","kind":"Gdef"},"wald":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.wald","kind":"Gdef"},"weibull":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.weibull","kind":"Gdef"},"zipf":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.zipf","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/random/__init__.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..8ffeb4c3e10880ade15da7d3606053dfbb811d80 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,2,3,4,5,6,7,1,1,1,1],"dep_prios":[5,5,5,5,5,5,5,5,30,30,30],"dependencies":["numpy.random._generator","numpy.random._mt19937","numpy.random._pcg64","numpy.random._philox","numpy.random._sfc64","numpy.random.bit_generator","numpy.random.mtrand","builtins","_frozen_importlib","abc","typing"],"hash":"49e12823e2cfa49a0e13334ef4bdcd401f2ac82c","id":"numpy.random","ignore_all":true,"interface_hash":"2ba456f603a5d953ec7f42c44d1aaeb22394b412","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/random/__init__.pyi","plugin_data":null,"size":2109,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/_generator.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/_generator.data.json new file mode 100644 index 0000000000000000000000000000000000000000..9112987e562b77715b74057417b21f8ef5216e92 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/_generator.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.random._generator","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"BitGenerator":{".class":"SymbolTableNode","cross_ref":"numpy.random.bit_generator.BitGenerator","kind":"Gdef","module_hidden":true,"module_public":false},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef","module_hidden":true,"module_public":false},"DTypeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like.DTypeLike","kind":"Gdef","module_hidden":true,"module_public":false},"Generator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.random._generator.Generator","name":"Generator","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.random._generator","mro":["numpy.random._generator.Generator","builtins.object"],"names":{".class":"SymbolTable","__getstate__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random._generator.Generator.__getstate__","name":"__getstate__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random._generator.Generator"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getstate__ of Generator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","bit_generator"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random._generator.Generator.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","bit_generator"],"arg_types":["numpy.random._generator.Generator","numpy.random.bit_generator.BitGenerator"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of Generator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__reduce__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random._generator.Generator.__reduce__","name":"__reduce__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random._generator.Generator"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__reduce__ of Generator","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["numpy.random.bit_generator.BitGenerator"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"numpy.random._generator.Generator","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"TupleType","implicit":false,"items":["numpy.random.bit_generator.BitGenerator"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random._generator.Generator.__repr__","name":"__repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["numpy.random._generator.Generator"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr__ of Generator","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__setstate__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","state"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random._generator.Generator.__setstate__","name":"__setstate__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","state"],"arg_types":["numpy.random._generator.Generator",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__setstate__ of Generator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__str__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random._generator.Generator.__str__","name":"__str__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["numpy.random._generator.Generator"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__str__ of Generator","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"beta":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.beta","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","a","b","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.beta","name":"beta","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","a","b","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"beta of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.beta","name":"beta","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","a","b","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"beta of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","a","b","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.beta","name":"beta","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","a","b","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"beta of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.beta","name":"beta","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","a","b","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"beta of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","a","b","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"beta of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","a","b","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"beta of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"binomial":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.binomial","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","n","p","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.binomial","name":"binomial","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","n","p","size"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"binomial of Generator","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.binomial","name":"binomial","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","n","p","size"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"binomial of Generator","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","n","p","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.binomial","name":"binomial","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","n","p","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"binomial of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.binomial","name":"binomial","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","n","p","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"binomial of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","n","p","size"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"binomial of Generator","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","n","p","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"binomial of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"bit_generator":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.bit_generator","name":"bit_generator","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random._generator.Generator"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"bit_generator of Generator","ret_type":"numpy.random.bit_generator.BitGenerator","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.bit_generator","name":"bit_generator","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random._generator.Generator"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"bit_generator of Generator","ret_type":"numpy.random.bit_generator.BitGenerator","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"bytes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","length"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random._generator.Generator.bytes","name":"bytes","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","length"],"arg_types":["numpy.random._generator.Generator","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"bytes of Generator","ret_type":"builtins.bytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"chisquare":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.chisquare","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","df","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.chisquare","name":"chisquare","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","df","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chisquare of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.chisquare","name":"chisquare","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","df","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chisquare of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","df","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.chisquare","name":"chisquare","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","df","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chisquare of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.chisquare","name":"chisquare","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","df","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chisquare of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","df","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chisquare of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","df","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chisquare of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"choice":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.choice","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1],"arg_names":["self","a","size","replace","p","axis","shuffle"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.choice","name":"choice","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":["self","a","size","replace","p","axis","shuffle"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"NoneType"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"choice of Generator","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.choice","name":"choice","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":["self","a","size","replace","p","axis","shuffle"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"NoneType"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"choice of Generator","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1],"arg_names":["self","a","size","replace","p","axis","shuffle"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.choice","name":"choice","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":["self","a","size","replace","p","axis","shuffle"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"choice of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.choice","name":"choice","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":["self","a","size","replace","p","axis","shuffle"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"choice of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1],"arg_names":["self","a","size","replace","p","axis","shuffle"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.choice","name":"choice","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":["self","a","size","replace","p","axis","shuffle"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"choice of Generator","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.choice","name":"choice","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":["self","a","size","replace","p","axis","shuffle"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"choice of Generator","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1],"arg_names":["self","a","size","replace","p","axis","shuffle"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.choice","name":"choice","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":["self","a","size","replace","p","axis","shuffle"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"choice of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.choice","name":"choice","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":["self","a","size","replace","p","axis","shuffle"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"choice of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":["self","a","size","replace","p","axis","shuffle"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"NoneType"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"choice of Generator","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":["self","a","size","replace","p","axis","shuffle"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"choice of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":["self","a","size","replace","p","axis","shuffle"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"choice of Generator","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":["self","a","size","replace","p","axis","shuffle"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"choice of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"dirichlet":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","alpha","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random._generator.Generator.dirichlet","name":"dirichlet","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","alpha","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dirichlet of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"exponential":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.exponential","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["self","scale","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.exponential","name":"exponential","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"exponential of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.exponential","name":"exponential","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"exponential of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["self","scale","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.exponential","name":"exponential","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"exponential of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.exponential","name":"exponential","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"exponential of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"exponential of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"exponential of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"f":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.f","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","dfnum","dfden","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.f","name":"f","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","dfnum","dfden","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"f of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.f","name":"f","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","dfnum","dfden","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"f of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","dfnum","dfden","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.f","name":"f","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","dfnum","dfden","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"f of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.f","name":"f","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","dfnum","dfden","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"f of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","dfnum","dfden","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"f of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","dfnum","dfden","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"f of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"gamma":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.gamma","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","shape","scale","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.gamma","name":"gamma","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","shape","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"gamma of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.gamma","name":"gamma","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","shape","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"gamma of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","shape","scale","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.gamma","name":"gamma","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","shape","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"gamma of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.gamma","name":"gamma","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","shape","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"gamma of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","shape","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"gamma of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","shape","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"gamma of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"geometric":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.geometric","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","p","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.geometric","name":"geometric","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","p","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"geometric of Generator","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.geometric","name":"geometric","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","p","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"geometric of Generator","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","p","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.geometric","name":"geometric","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","p","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"geometric of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.geometric","name":"geometric","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","p","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"geometric of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","p","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"geometric of Generator","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","p","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"geometric of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"gumbel":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.gumbel","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.gumbel","name":"gumbel","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"gumbel of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.gumbel","name":"gumbel","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"gumbel of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.gumbel","name":"gumbel","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"gumbel of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.gumbel","name":"gumbel","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"gumbel of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"gumbel of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"gumbel of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"hypergeometric":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.hypergeometric","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1],"arg_names":["self","ngood","nbad","nsample","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.hypergeometric","name":"hypergeometric","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","ngood","nbad","nsample","size"],"arg_types":["numpy.random._generator.Generator","builtins.int","builtins.int","builtins.int",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hypergeometric of Generator","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.hypergeometric","name":"hypergeometric","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","ngood","nbad","nsample","size"],"arg_types":["numpy.random._generator.Generator","builtins.int","builtins.int","builtins.int",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hypergeometric of Generator","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1],"arg_names":["self","ngood","nbad","nsample","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.hypergeometric","name":"hypergeometric","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","ngood","nbad","nsample","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hypergeometric of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.hypergeometric","name":"hypergeometric","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","ngood","nbad","nsample","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hypergeometric of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","ngood","nbad","nsample","size"],"arg_types":["numpy.random._generator.Generator","builtins.int","builtins.int","builtins.int",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hypergeometric of Generator","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","ngood","nbad","nsample","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hypergeometric of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"integers":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.integers","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1],"arg_names":["self","low","high","size","dtype","endpoint"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int64Codes"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int64Codes"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeType","item":"builtins.bool"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeType","item":"builtins.bool"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeType","item":"builtins.int"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeType","item":"builtins.int"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._BoolCodes"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._BoolCodes"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random._generator._IntegerT","id":-1,"name":"_IntegerT","namespace":"numpy.random._generator.Generator.integers#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random._generator._IntegerT","id":-1,"name":"_IntegerT","namespace":"numpy.random._generator.Generator.integers#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random._generator._IntegerT","id":-1,"name":"_IntegerT","namespace":"numpy.random._generator.Generator.integers#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random._generator._IntegerT","id":-1,"name":"_IntegerT","namespace":"numpy.random._generator.Generator.integers#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1],"arg_names":["self","low","high","size","dtype","endpoint"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int64Codes"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int64Codes"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random._generator._IntegerT","id":-1,"name":"_IntegerT","namespace":"numpy.random._generator.Generator.integers#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random._generator._IntegerT","id":-1,"name":"_IntegerT","namespace":"numpy.random._generator.Generator.integers#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},"values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int8Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int8Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int8Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int8Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt8Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt8Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt8Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt8Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int16Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int16Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int16Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int16Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt16Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt16Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt16Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt16Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int32Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int32Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int32Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int32Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt32Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt32Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt32Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt32Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt64Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt64Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt64Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt64Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._IntPCodes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._IntPCodes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._IntPCodes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._IntPCodes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UIntPCodes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UIntPCodes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UIntPCodes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UIntPCodes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1],"arg_names":["self","low","high","size","dtype","endpoint"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1],"arg_names":["self","low","high","size","dtype","endpoint"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.integers","name":"integers","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int64Codes"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeType","item":"builtins.bool"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeType","item":"builtins.int"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._BoolCodes"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random._generator._IntegerT","id":-1,"name":"_IntegerT","namespace":"numpy.random._generator.Generator.integers#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random._generator._IntegerT","id":-1,"name":"_IntegerT","namespace":"numpy.random._generator.Generator.integers#4","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int64Codes"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random._generator._IntegerT","id":-1,"name":"_IntegerT","namespace":"numpy.random._generator.Generator.integers#7","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},"values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int8Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int8Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt8Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt8Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int16Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int16Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt16Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt16Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int32Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int32Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt32Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt32Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt64Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt64Codes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._IntPCodes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.intp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._IntPCodes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UIntPCodes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,3,5],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UIntPCodes"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["self","low","high","size","dtype","endpoint"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"integers of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"laplace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.laplace","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.laplace","name":"laplace","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"laplace of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.laplace","name":"laplace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"laplace of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.laplace","name":"laplace","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"laplace of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.laplace","name":"laplace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"laplace of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"laplace of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"laplace of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"logistic":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.logistic","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.logistic","name":"logistic","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logistic of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.logistic","name":"logistic","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logistic of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.logistic","name":"logistic","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logistic of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.logistic","name":"logistic","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logistic of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logistic of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logistic of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"lognormal":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.lognormal","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","mean","sigma","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.lognormal","name":"lognormal","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","mean","sigma","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lognormal of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.lognormal","name":"lognormal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","mean","sigma","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lognormal of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","mean","sigma","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.lognormal","name":"lognormal","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","mean","sigma","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lognormal of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.lognormal","name":"lognormal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","mean","sigma","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lognormal of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","mean","sigma","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lognormal of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","mean","sigma","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lognormal of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"logseries":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.logseries","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","p","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.logseries","name":"logseries","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","p","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logseries of Generator","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.logseries","name":"logseries","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","p","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logseries of Generator","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","p","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.logseries","name":"logseries","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","p","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logseries of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.logseries","name":"logseries","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","p","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logseries of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","p","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logseries of Generator","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","p","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logseries of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"multinomial":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","n","pvals","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random._generator.Generator.multinomial","name":"multinomial","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","n","pvals","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"multinomial of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"multivariate_hypergeometric":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1],"arg_names":["self","colors","nsample","size","method"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random._generator.Generator.multivariate_hypergeometric","name":"multivariate_hypergeometric","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1],"arg_names":["self","colors","nsample","size","method"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"marginals"},{".class":"LiteralType","fallback":"builtins.str","value":"count"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"multivariate_hypergeometric of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"multivariate_normal":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1,5],"arg_names":["self","mean","cov","size","check_valid","tol","method"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random._generator.Generator.multivariate_normal","name":"multivariate_normal","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,5],"arg_names":["self","mean","cov","size","check_valid","tol","method"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"warn"},{".class":"LiteralType","fallback":"builtins.str","value":"raise"},{".class":"LiteralType","fallback":"builtins.str","value":"ignore"}],"uses_pep604_syntax":false},"builtins.float",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"svd"},{".class":"LiteralType","fallback":"builtins.str","value":"eigh"},{".class":"LiteralType","fallback":"builtins.str","value":"cholesky"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"multivariate_normal of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"negative_binomial":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.negative_binomial","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","n","p","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.negative_binomial","name":"negative_binomial","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","n","p","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"negative_binomial of Generator","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.negative_binomial","name":"negative_binomial","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","n","p","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"negative_binomial of Generator","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","n","p","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.negative_binomial","name":"negative_binomial","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","n","p","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"negative_binomial of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.negative_binomial","name":"negative_binomial","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","n","p","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"negative_binomial of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","n","p","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"negative_binomial of Generator","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","n","p","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"negative_binomial of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"noncentral_chisquare":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.noncentral_chisquare","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","df","nonc","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.noncentral_chisquare","name":"noncentral_chisquare","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","df","nonc","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"noncentral_chisquare of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.noncentral_chisquare","name":"noncentral_chisquare","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","df","nonc","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"noncentral_chisquare of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","df","nonc","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.noncentral_chisquare","name":"noncentral_chisquare","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","df","nonc","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"noncentral_chisquare of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.noncentral_chisquare","name":"noncentral_chisquare","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","df","nonc","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"noncentral_chisquare of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","df","nonc","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"noncentral_chisquare of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","df","nonc","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"noncentral_chisquare of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"noncentral_f":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.noncentral_f","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1],"arg_names":["self","dfnum","dfden","nonc","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.noncentral_f","name":"noncentral_f","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","dfnum","dfden","nonc","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"noncentral_f of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.noncentral_f","name":"noncentral_f","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","dfnum","dfden","nonc","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"noncentral_f of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1],"arg_names":["self","dfnum","dfden","nonc","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.noncentral_f","name":"noncentral_f","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","dfnum","dfden","nonc","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"noncentral_f of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.noncentral_f","name":"noncentral_f","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","dfnum","dfden","nonc","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"noncentral_f of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","dfnum","dfden","nonc","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"noncentral_f of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","dfnum","dfden","nonc","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"noncentral_f of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"normal":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.normal","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.normal","name":"normal","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"normal of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.normal","name":"normal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"normal of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.normal","name":"normal","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"normal of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.normal","name":"normal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"normal of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"normal of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"normal of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"pareto":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.pareto","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","a","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.pareto","name":"pareto","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pareto of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.pareto","name":"pareto","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pareto of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","a","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.pareto","name":"pareto","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pareto of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.pareto","name":"pareto","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pareto of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pareto of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pareto of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"permutation":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.permutation","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","x","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.permutation","name":"permutation","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","x","axis"],"arg_types":["numpy.random._generator.Generator","builtins.int","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"permutation of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.permutation","name":"permutation","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","x","axis"],"arg_types":["numpy.random._generator.Generator","builtins.int","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"permutation of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","x","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.permutation","name":"permutation","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","x","axis"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"permutation of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.permutation","name":"permutation","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","x","axis"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"permutation of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","x","axis"],"arg_types":["numpy.random._generator.Generator","builtins.int","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"permutation of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","x","axis"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"permutation of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"permuted":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5],"arg_names":["self","x","axis","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random._generator.Generator.permuted","name":"permuted","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5],"arg_names":["self","x","axis","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"permuted of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"poisson":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.poisson","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["self","lam","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.poisson","name":"poisson","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","lam","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"poisson of Generator","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.poisson","name":"poisson","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","lam","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"poisson of Generator","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["self","lam","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.poisson","name":"poisson","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","lam","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"poisson of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.poisson","name":"poisson","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","lam","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"poisson of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","lam","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"poisson of Generator","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","lam","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"poisson of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"power":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.power","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","a","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.power","name":"power","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"power of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.power","name":"power","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"power of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","a","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.power","name":"power","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"power of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.power","name":"power","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"power of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"power of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"power of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"random":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.random","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","size","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.random","name":"random","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","size","dtype","out"],"arg_types":["numpy.random._generator.Generator",{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.random","name":"random","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","size","dtype","out"],"arg_types":["numpy.random._generator.Generator",{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5],"arg_names":["self","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.random","name":"random","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5],"arg_names":["self","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.random","name":"random","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5],"arg_names":["self","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,5],"arg_names":["self","size","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.random","name":"random","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,5],"arg_names":["self","size","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.random","name":"random","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,5],"arg_names":["self","size","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","size","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.random","name":"random","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","size","dtype","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.random","name":"random","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","size","dtype","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","size","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.random","name":"random","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","size","dtype","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.random","name":"random","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","size","dtype","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","size","dtype","out"],"arg_types":["numpy.random._generator.Generator",{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,5],"arg_names":["self","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,5],"arg_names":["self","size","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","size","dtype","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","size","dtype","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"rayleigh":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.rayleigh","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["self","scale","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.rayleigh","name":"rayleigh","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rayleigh of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.rayleigh","name":"rayleigh","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rayleigh of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["self","scale","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.rayleigh","name":"rayleigh","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rayleigh of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.rayleigh","name":"rayleigh","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rayleigh of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rayleigh of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rayleigh of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"shuffle":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.shuffle","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":[null,"x","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.shuffle","name":"shuffle","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":[null,"x","axis"],"arg_types":["numpy.random._generator.Generator",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shuffle of Generator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.shuffle","name":"shuffle","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":[null,"x","axis"],"arg_types":["numpy.random._generator.Generator",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shuffle of Generator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":[null,"x","axis"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.shuffle","name":"shuffle","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":[null,"x","axis"],"arg_types":["numpy.random._generator.Generator",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.MutableSequence"},{".class":"LiteralType","fallback":"builtins.int","value":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shuffle of Generator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.shuffle","name":"shuffle","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":[null,"x","axis"],"arg_types":["numpy.random._generator.Generator",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.MutableSequence"},{".class":"LiteralType","fallback":"builtins.int","value":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shuffle of Generator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":[null,"x","axis"],"arg_types":["numpy.random._generator.Generator",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy.ndarray"},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shuffle of Generator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":[null,"x","axis"],"arg_types":["numpy.random._generator.Generator",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.MutableSequence"},{".class":"LiteralType","fallback":"builtins.int","value":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shuffle of Generator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"spawn":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","n_children"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random._generator.Generator.spawn","name":"spawn","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","n_children"],"arg_types":["numpy.random._generator.Generator","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"spawn of Generator","ret_type":{".class":"Instance","args":["numpy.random._generator.Generator"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"standard_cauchy":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.standard_cauchy","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.standard_cauchy","name":"standard_cauchy","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size"],"arg_types":["numpy.random._generator.Generator",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_cauchy of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.standard_cauchy","name":"standard_cauchy","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size"],"arg_types":["numpy.random._generator.Generator",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_cauchy of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.standard_cauchy","name":"standard_cauchy","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_cauchy of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.standard_cauchy","name":"standard_cauchy","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_cauchy of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size"],"arg_types":["numpy.random._generator.Generator",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_cauchy of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_cauchy of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"standard_exponential":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.standard_exponential","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["self","size","dtype","method","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.standard_exponential","name":"standard_exponential","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["self","size","dtype","method","out"],"arg_types":["numpy.random._generator.Generator",{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"zig"},{".class":"LiteralType","fallback":"builtins.str","value":"inv"}],"uses_pep604_syntax":false},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_exponential of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.standard_exponential","name":"standard_exponential","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["self","size","dtype","method","out"],"arg_types":["numpy.random._generator.Generator",{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"zig"},{".class":"LiteralType","fallback":"builtins.str","value":"inv"}],"uses_pep604_syntax":false},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_exponential of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.standard_exponential","name":"standard_exponential","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_exponential of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.standard_exponential","name":"standard_exponential","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_exponential of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5],"arg_names":["self","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.standard_exponential","name":"standard_exponential","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5],"arg_names":["self","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_exponential of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.standard_exponential","name":"standard_exponential","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5],"arg_names":["self","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_exponential of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,5,5],"arg_names":["self","size","method","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.standard_exponential","name":"standard_exponential","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,5,5],"arg_names":["self","size","method","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"zig"},{".class":"LiteralType","fallback":"builtins.str","value":"inv"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_exponential of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.standard_exponential","name":"standard_exponential","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,5,5],"arg_names":["self","size","method","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"zig"},{".class":"LiteralType","fallback":"builtins.str","value":"inv"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_exponential of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["self","size","dtype","method","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.standard_exponential","name":"standard_exponential","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["self","size","dtype","method","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"zig"},{".class":"LiteralType","fallback":"builtins.str","value":"inv"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_exponential of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.standard_exponential","name":"standard_exponential","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["self","size","dtype","method","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"zig"},{".class":"LiteralType","fallback":"builtins.str","value":"inv"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_exponential of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1],"arg_names":["self","size","dtype","method","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.standard_exponential","name":"standard_exponential","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["self","size","dtype","method","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"zig"},{".class":"LiteralType","fallback":"builtins.str","value":"inv"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_exponential of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.standard_exponential","name":"standard_exponential","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["self","size","dtype","method","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"zig"},{".class":"LiteralType","fallback":"builtins.str","value":"inv"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_exponential of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["self","size","dtype","method","out"],"arg_types":["numpy.random._generator.Generator",{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"zig"},{".class":"LiteralType","fallback":"builtins.str","value":"inv"}],"uses_pep604_syntax":false},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_exponential of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_exponential of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,5],"arg_names":["self","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_exponential of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,5,5],"arg_names":["self","size","method","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"zig"},{".class":"LiteralType","fallback":"builtins.str","value":"inv"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_exponential of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["self","size","dtype","method","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"zig"},{".class":"LiteralType","fallback":"builtins.str","value":"inv"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_exponential of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1],"arg_names":["self","size","dtype","method","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"zig"},{".class":"LiteralType","fallback":"builtins.str","value":"inv"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_exponential of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"standard_gamma":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.standard_gamma","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["self","shape","size","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.standard_gamma","name":"standard_gamma","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","shape","size","dtype","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_gamma of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.standard_gamma","name":"standard_gamma","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","shape","size","dtype","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_gamma of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","shape","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.standard_gamma","name":"standard_gamma","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","shape","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_gamma of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.standard_gamma","name":"standard_gamma","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","shape","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_gamma of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5],"arg_names":["self","shape","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.standard_gamma","name":"standard_gamma","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["self","shape","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_gamma of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.standard_gamma","name":"standard_gamma","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["self","shape","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_gamma of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["self","shape","size","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.standard_gamma","name":"standard_gamma","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","shape","size","dtype","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_gamma of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.standard_gamma","name":"standard_gamma","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","shape","size","dtype","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_gamma of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["self","shape","size","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.standard_gamma","name":"standard_gamma","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","shape","size","dtype","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_gamma of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.standard_gamma","name":"standard_gamma","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","shape","size","dtype","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_gamma of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","shape","size","dtype","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_gamma of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","shape","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_gamma of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["self","shape","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_gamma of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","shape","size","dtype","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_gamma of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","shape","size","dtype","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_gamma of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"standard_normal":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.standard_normal","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","size","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.standard_normal","name":"standard_normal","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","size","dtype","out"],"arg_types":["numpy.random._generator.Generator",{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_normal of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.standard_normal","name":"standard_normal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","size","dtype","out"],"arg_types":["numpy.random._generator.Generator",{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_normal of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.standard_normal","name":"standard_normal","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_normal of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.standard_normal","name":"standard_normal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_normal of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5],"arg_names":["self","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.standard_normal","name":"standard_normal","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5],"arg_names":["self","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_normal of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.standard_normal","name":"standard_normal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5],"arg_names":["self","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_normal of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","size","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.standard_normal","name":"standard_normal","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","size","dtype","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_normal of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.standard_normal","name":"standard_normal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","size","dtype","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_normal of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","size","dtype","out"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.standard_normal","name":"standard_normal","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","size","dtype","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_normal of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.standard_normal","name":"standard_normal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","size","dtype","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_normal of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","size","dtype","out"],"arg_types":["numpy.random._generator.Generator",{".class":"NoneType"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_normal of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_normal of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,5],"arg_names":["self","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_normal of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","size","dtype","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_normal of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","size","dtype","out"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_normal of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"standard_t":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.standard_t","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","df","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.standard_t","name":"standard_t","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","df","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_t of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.standard_t","name":"standard_t","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","df","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_t of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","df","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.standard_t","name":"standard_t","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","df","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_t of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.standard_t","name":"standard_t","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","df","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_t of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","df","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.standard_t","name":"standard_t","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","df","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_t of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.standard_t","name":"standard_t","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","df","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_t of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","df","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_t of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","df","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_t of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","df","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_t of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"triangular":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.triangular","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1],"arg_names":["self","left","mode","right","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.triangular","name":"triangular","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","left","mode","right","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"triangular of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.triangular","name":"triangular","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","left","mode","right","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"triangular of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1],"arg_names":["self","left","mode","right","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.triangular","name":"triangular","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","left","mode","right","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"triangular of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.triangular","name":"triangular","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","left","mode","right","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"triangular of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","left","mode","right","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"triangular of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","left","mode","right","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"triangular of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"uniform":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.uniform","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","low","high","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.uniform","name":"uniform","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","low","high","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"uniform of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.uniform","name":"uniform","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","low","high","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"uniform of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","low","high","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.uniform","name":"uniform","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","low","high","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"uniform of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.uniform","name":"uniform","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","low","high","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"uniform of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","low","high","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"uniform of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","low","high","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"uniform of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"vonmises":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.vonmises","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","mu","kappa","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.vonmises","name":"vonmises","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","mu","kappa","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vonmises of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.vonmises","name":"vonmises","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","mu","kappa","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vonmises of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","mu","kappa","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.vonmises","name":"vonmises","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","mu","kappa","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vonmises of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.vonmises","name":"vonmises","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","mu","kappa","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vonmises of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","mu","kappa","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vonmises of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","mu","kappa","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vonmises of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"wald":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.wald","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","mean","scale","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.wald","name":"wald","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","mean","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"wald of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.wald","name":"wald","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","mean","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"wald of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","mean","scale","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.wald","name":"wald","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","mean","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"wald of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.wald","name":"wald","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","mean","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"wald of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","mean","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"wald of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","mean","scale","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"wald of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"weibull":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.weibull","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","a","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.weibull","name":"weibull","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"weibull of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.weibull","name":"weibull","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"weibull of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","a","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.weibull","name":"weibull","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"weibull of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.weibull","name":"weibull","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"weibull of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"weibull of Generator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"weibull of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"zipf":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random._generator.Generator.zipf","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","a","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.zipf","name":"zipf","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zipf of Generator","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.zipf","name":"zipf","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zipf of Generator","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","a","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._generator.Generator.zipf","name":"zipf","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zipf of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random._generator.Generator.zipf","name":"zipf","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zipf of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._scalars.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zipf of Generator","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random._generator.Generator",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zipf of Generator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random._generator.Generator.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.random._generator.Generator","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"MutableSequence":{".class":"SymbolTableNode","cross_ref":"typing.MutableSequence","kind":"Gdef","module_hidden":true,"module_public":false},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"RandomState":{".class":"SymbolTableNode","cross_ref":"numpy.random.mtrand.RandomState","kind":"Gdef","module_hidden":true,"module_public":false},"SeedSequence":{".class":"SymbolTableNode","cross_ref":"numpy.random.bit_generator.SeedSequence","kind":"Gdef","module_hidden":true,"module_public":false},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.random._generator.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3}}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeFloat_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeFloat_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeInt_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeInt_co","kind":"Gdef","module_hidden":true,"module_public":false},"_BoolCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._BoolCodes","kind":"Gdef","module_hidden":true,"module_public":false},"_DTypeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._DTypeLike","kind":"Gdef","module_hidden":true,"module_public":false},"_DTypeLikeBool":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._DTypeLikeBool","kind":"Gdef","module_hidden":true,"module_public":false},"_DTypeLikeFloat32":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.random._generator._DTypeLikeFloat32","name":"_DTypeLikeFloat32","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3}}},"_DTypeLikeFloat64":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.random._generator._DTypeLikeFloat64","name":"_DTypeLikeFloat64","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.random._generator.TypeAlias","source_any":null,"type_of_any":3}}},"_DoubleCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._DoubleCodes","kind":"Gdef","module_hidden":true,"module_public":false},"_Float32Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._Float32Codes","kind":"Gdef","module_hidden":true,"module_public":false},"_Float64Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._Float64Codes","kind":"Gdef","module_hidden":true,"module_public":false},"_FloatLike_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._scalars._FloatLike_co","kind":"Gdef","module_hidden":true,"module_public":false},"_Int16Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._Int16Codes","kind":"Gdef","module_hidden":true,"module_public":false},"_Int32Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._Int32Codes","kind":"Gdef","module_hidden":true,"module_public":false},"_Int64Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._Int64Codes","kind":"Gdef","module_hidden":true,"module_public":false},"_Int8Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._Int8Codes","kind":"Gdef","module_hidden":true,"module_public":false},"_IntPCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._IntPCodes","kind":"Gdef","module_hidden":true,"module_public":false},"_IntegerT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random._generator._IntegerT","name":"_IntegerT","upper_bound":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"numpy.integer"},"values":[],"variance":0}},"_ShapeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._shape._ShapeLike","kind":"Gdef","module_hidden":true,"module_public":false},"_SingleCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._SingleCodes","kind":"Gdef","module_hidden":true,"module_public":false},"_SupportsDType":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._SupportsDType","kind":"Gdef","module_hidden":true,"module_public":false},"_UInt16Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._UInt16Codes","kind":"Gdef","module_hidden":true,"module_public":false},"_UInt32Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._UInt32Codes","kind":"Gdef","module_hidden":true,"module_public":false},"_UInt64Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._UInt64Codes","kind":"Gdef","module_hidden":true,"module_public":false},"_UInt8Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._UInt8Codes","kind":"Gdef","module_hidden":true,"module_public":false},"_UIntPCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._UIntPCodes","kind":"Gdef","module_hidden":true,"module_public":false},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random._generator.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random._generator.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random._generator.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random._generator.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random._generator.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random._generator.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"default_rng":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1],"arg_names":["seed"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.random._generator.default_rng","name":"default_rng","original_first_arg":"seed","type":{".class":"CallableType","arg_kinds":[1],"arg_names":["seed"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy.random.bit_generator.SeedSequence","numpy.random.bit_generator.BitGenerator","numpy.random._generator.Generator","numpy.random.mtrand.RandomState",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"default_rng","ret_type":"numpy.random._generator.Generator","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"dtype":{".class":"SymbolTableNode","cross_ref":"numpy.dtype","kind":"Gdef","module_hidden":true,"module_public":false},"float32":{".class":"SymbolTableNode","cross_ref":"numpy.float32","kind":"Gdef","module_hidden":true,"module_public":false},"float64":{".class":"SymbolTableNode","cross_ref":"numpy.float64","kind":"Gdef","module_hidden":true,"module_public":false},"int64":{".class":"SymbolTableNode","cross_ref":"numpy.int64","kind":"Gdef","module_hidden":true,"module_public":false},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/random/_generator.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/_generator.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/_generator.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..c6604efc3cb8d263225519975dabfd2bbfa06a06 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/_generator.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,6,33,2,4,1,1,1,1,1,1,1,1,1,1,1,1,1,1],"dep_prios":[5,5,5,5,5,5,30,30,30,30,30,30,30,30,30,30,30,30,30],"dependencies":["collections.abc","numpy._typing","numpy.random","typing","numpy","builtins","_ctypes","_frozen_importlib","abc","ctypes","datetime","numpy._typing._char_codes","numpy._typing._dtype_like","numpy._typing._nbit_base","numpy.dtypes","numpy.random.bit_generator","numpy.random.mtrand","types","typing_extensions"],"hash":"e77870a72d8dd68fbbd811c730568c83a94f727c","id":"numpy.random._generator","ignore_all":true,"interface_hash":"647dcc4200c8ab9b2ccd700d975c6ff1a655574a","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/random/_generator.pyi","plugin_data":null,"size":24183,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/_mt19937.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/_mt19937.data.json new file mode 100644 index 0000000000000000000000000000000000000000..11a2e43d2aa4ee1a2a4be69dd966150c7a7b0af1 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/_mt19937.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.random._mt19937","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","BitGenerator":{".class":"SymbolTableNode","cross_ref":"numpy.random.bit_generator.BitGenerator","kind":"Gdef","module_hidden":true,"module_public":false},"MT19937":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy.random.bit_generator.BitGenerator"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.random._mt19937.MT19937","name":"MT19937","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.random._mt19937.MT19937","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.random._mt19937","mro":["numpy.random._mt19937.MT19937","numpy.random.bit_generator.BitGenerator","numpy.random.bit_generator._CythonMixin","abc.ABC","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","seed"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random._mt19937.MT19937.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","seed"],"arg_types":["numpy.random._mt19937.MT19937",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy.random.bit_generator.SeedSequence",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of MT19937","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_legacy_seeding":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","seed"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random._mt19937.MT19937._legacy_seeding","name":"_legacy_seeding","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","seed"],"arg_types":["numpy.random._mt19937.MT19937",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_legacy_seeding of MT19937","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"jumped":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","jumps"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random._mt19937.MT19937.jumped","name":"jumped","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","jumps"],"arg_types":["numpy.random._mt19937.MT19937","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"jumped of MT19937","ret_type":"numpy.random._mt19937.MT19937","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"state":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":["is_property"],"fullname":"numpy.random._mt19937.MT19937.state","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._mt19937.MT19937.state","name":"state","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random._mt19937.MT19937"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of MT19937","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.random._mt19937._MT19937State"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_settable_property","is_ready","is_inferred"],"fullname":"numpy.random._mt19937.MT19937.state","name":"state","setter_type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","value"],"arg_types":["numpy.random._mt19937.MT19937",{".class":"TypeAliasType","args":[],"type_ref":"numpy.random._mt19937._MT19937State"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of MT19937","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random._mt19937.MT19937"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of MT19937","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.random._mt19937._MT19937State"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated","is_trivial_self"],"fullname":"numpy.random._mt19937.MT19937.state","name":"state","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","value"],"arg_types":["numpy.random._mt19937.MT19937",{".class":"TypeAliasType","args":[],"type_ref":"numpy.random._mt19937._MT19937State"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of MT19937","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"","name":"state","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","value"],"arg_types":["numpy.random._mt19937.MT19937",{".class":"TypeAliasType","args":[],"type_ref":"numpy.random._mt19937._MT19937State"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of MT19937","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":1,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random._mt19937.MT19937"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of MT19937","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.random._mt19937._MT19937State"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random._mt19937.MT19937.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.random._mt19937.MT19937","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"SeedSequence":{".class":"SymbolTableNode","cross_ref":"numpy.random.bit_generator.SeedSequence","kind":"Gdef","module_hidden":true,"module_public":false},"TypedDict":{".class":"SymbolTableNode","cross_ref":"typing.TypedDict","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeInt_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeInt_co","kind":"Gdef","module_hidden":true,"module_public":false},"_MT19937Internal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.random._mt19937._MT19937Internal","name":"_MT19937Internal","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.random._mt19937._MT19937Internal","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.random._mt19937","mro":["numpy.random._mt19937._MT19937Internal","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["key",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],["pos","builtins.int"]],"readonly_keys":[],"required_keys":["key","pos"]}}},"_MT19937State":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.random._mt19937._MT19937State","name":"_MT19937State","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.random._mt19937._MT19937State","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.random._mt19937","mro":["numpy.random._mt19937._MT19937State","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["bit_generator","builtins.str"],["state",{".class":"TypeAliasType","args":[],"type_ref":"numpy.random._mt19937._MT19937Internal"}]],"readonly_keys":[],"required_keys":["bit_generator","state"]}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random._mt19937.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random._mt19937.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random._mt19937.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random._mt19937.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random._mt19937.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random._mt19937.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"type_check_only":{".class":"SymbolTableNode","cross_ref":"typing.type_check_only","kind":"Gdef","module_hidden":true,"module_public":false},"uint32":{".class":"SymbolTableNode","cross_ref":"numpy.uint32","kind":"Gdef","module_hidden":true,"module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/random/_mt19937.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/_mt19937.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/_mt19937.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..868d7a932874fbff54b43ae9685371f412b065c4 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/_mt19937.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[5,4,6,1,3,1,1,1],"dep_prios":[5,5,5,5,5,5,30,30],"dependencies":["numpy.random.bit_generator","numpy._typing","numpy.typing","typing","numpy","builtins","_frozen_importlib","abc"],"hash":"86b4a562709169f4daf7f69639110772eaa2d2c9","id":"numpy.random._mt19937","ignore_all":true,"interface_hash":"4781adc97fca2c586b087eef099e363de15fb9d0","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/random/_mt19937.pyi","plugin_data":null,"size":775,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/_pcg64.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/_pcg64.data.json new file mode 100644 index 0000000000000000000000000000000000000000..ef46983930c6ce6029a22a8c442bfce4435edbad --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/_pcg64.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.random._pcg64","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","BitGenerator":{".class":"SymbolTableNode","cross_ref":"numpy.random.bit_generator.BitGenerator","kind":"Gdef","module_hidden":true,"module_public":false},"PCG64":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy.random.bit_generator.BitGenerator"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.random._pcg64.PCG64","name":"PCG64","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.random._pcg64.PCG64","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.random._pcg64","mro":["numpy.random._pcg64.PCG64","numpy.random.bit_generator.BitGenerator","numpy.random.bit_generator._CythonMixin","abc.ABC","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","seed"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random._pcg64.PCG64.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","seed"],"arg_types":["numpy.random._pcg64.PCG64",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy.random.bit_generator.SeedSequence",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of PCG64","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"advance":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","delta"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random._pcg64.PCG64.advance","name":"advance","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","delta"],"arg_types":["numpy.random._pcg64.PCG64","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"advance of PCG64","ret_type":"numpy.random._pcg64.PCG64","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"jumped":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","jumps"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random._pcg64.PCG64.jumped","name":"jumped","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","jumps"],"arg_types":["numpy.random._pcg64.PCG64","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"jumped of PCG64","ret_type":"numpy.random._pcg64.PCG64","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"state":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":["is_property"],"fullname":"numpy.random._pcg64.PCG64.state","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._pcg64.PCG64.state","name":"state","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random._pcg64.PCG64"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of PCG64","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.random._pcg64._PCG64State"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_settable_property","is_ready","is_inferred"],"fullname":"numpy.random._pcg64.PCG64.state","name":"state","setter_type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","value"],"arg_types":["numpy.random._pcg64.PCG64",{".class":"TypeAliasType","args":[],"type_ref":"numpy.random._pcg64._PCG64State"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of PCG64","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random._pcg64.PCG64"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of PCG64","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.random._pcg64._PCG64State"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated","is_trivial_self"],"fullname":"numpy.random._pcg64.PCG64.state","name":"state","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","value"],"arg_types":["numpy.random._pcg64.PCG64",{".class":"TypeAliasType","args":[],"type_ref":"numpy.random._pcg64._PCG64State"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of PCG64","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"","name":"state","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","value"],"arg_types":["numpy.random._pcg64.PCG64",{".class":"TypeAliasType","args":[],"type_ref":"numpy.random._pcg64._PCG64State"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of PCG64","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":1,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random._pcg64.PCG64"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of PCG64","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.random._pcg64._PCG64State"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random._pcg64.PCG64.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.random._pcg64.PCG64","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"PCG64DXSM":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy.random.bit_generator.BitGenerator"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.random._pcg64.PCG64DXSM","name":"PCG64DXSM","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.random._pcg64.PCG64DXSM","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.random._pcg64","mro":["numpy.random._pcg64.PCG64DXSM","numpy.random.bit_generator.BitGenerator","numpy.random.bit_generator._CythonMixin","abc.ABC","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","seed"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random._pcg64.PCG64DXSM.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","seed"],"arg_types":["numpy.random._pcg64.PCG64DXSM",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy.random.bit_generator.SeedSequence",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of PCG64DXSM","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"advance":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","delta"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random._pcg64.PCG64DXSM.advance","name":"advance","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","delta"],"arg_types":["numpy.random._pcg64.PCG64DXSM","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"advance of PCG64DXSM","ret_type":"numpy.random._pcg64.PCG64DXSM","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"jumped":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","jumps"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random._pcg64.PCG64DXSM.jumped","name":"jumped","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","jumps"],"arg_types":["numpy.random._pcg64.PCG64DXSM","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"jumped of PCG64DXSM","ret_type":"numpy.random._pcg64.PCG64DXSM","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"state":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":["is_property"],"fullname":"numpy.random._pcg64.PCG64DXSM.state","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._pcg64.PCG64DXSM.state","name":"state","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random._pcg64.PCG64DXSM"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of PCG64DXSM","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.random._pcg64._PCG64State"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_settable_property","is_ready","is_inferred"],"fullname":"numpy.random._pcg64.PCG64DXSM.state","name":"state","setter_type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","value"],"arg_types":["numpy.random._pcg64.PCG64DXSM",{".class":"TypeAliasType","args":[],"type_ref":"numpy.random._pcg64._PCG64State"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of PCG64DXSM","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random._pcg64.PCG64DXSM"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of PCG64DXSM","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.random._pcg64._PCG64State"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated","is_trivial_self"],"fullname":"numpy.random._pcg64.PCG64DXSM.state","name":"state","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","value"],"arg_types":["numpy.random._pcg64.PCG64DXSM",{".class":"TypeAliasType","args":[],"type_ref":"numpy.random._pcg64._PCG64State"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of PCG64DXSM","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"","name":"state","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","value"],"arg_types":["numpy.random._pcg64.PCG64DXSM",{".class":"TypeAliasType","args":[],"type_ref":"numpy.random._pcg64._PCG64State"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of PCG64DXSM","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":1,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random._pcg64.PCG64DXSM"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of PCG64DXSM","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.random._pcg64._PCG64State"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random._pcg64.PCG64DXSM.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.random._pcg64.PCG64DXSM","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"SeedSequence":{".class":"SymbolTableNode","cross_ref":"numpy.random.bit_generator.SeedSequence","kind":"Gdef","module_hidden":true,"module_public":false},"TypedDict":{".class":"SymbolTableNode","cross_ref":"typing.TypedDict","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeInt_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeInt_co","kind":"Gdef","module_hidden":true,"module_public":false},"_PCG64Internal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.random._pcg64._PCG64Internal","name":"_PCG64Internal","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.random._pcg64._PCG64Internal","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.random._pcg64","mro":["numpy.random._pcg64._PCG64Internal","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["state","builtins.int"],["inc","builtins.int"]],"readonly_keys":[],"required_keys":["inc","state"]}}},"_PCG64State":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.random._pcg64._PCG64State","name":"_PCG64State","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.random._pcg64._PCG64State","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.random._pcg64","mro":["numpy.random._pcg64._PCG64State","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["bit_generator","builtins.str"],["state",{".class":"TypeAliasType","args":[],"type_ref":"numpy.random._pcg64._PCG64Internal"}],["has_uint32","builtins.int"],["uinteger","builtins.int"]],"readonly_keys":[],"required_keys":["bit_generator","has_uint32","state","uinteger"]}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random._pcg64.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random._pcg64.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random._pcg64.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random._pcg64.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random._pcg64.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random._pcg64.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"type_check_only":{".class":"SymbolTableNode","cross_ref":"typing.type_check_only","kind":"Gdef","module_hidden":true,"module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/random/_pcg64.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/_pcg64.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/_pcg64.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..e838922dcefeab735f08be88bb321b8540a7bc47 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/_pcg64.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[4,3,1,1,1,1],"dep_prios":[5,5,5,5,30,30],"dependencies":["numpy.random.bit_generator","numpy._typing","typing","builtins","_frozen_importlib","abc"],"hash":"4c470372b0d3227ab742d2adb1c89df77ae06503","id":"numpy.random._pcg64","ignore_all":true,"interface_hash":"2738ace82e7cdb8e49d3b5c665d67e7a5fd15691","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/random/_pcg64.pyi","plugin_data":null,"size":1142,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/_philox.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/_philox.data.json new file mode 100644 index 0000000000000000000000000000000000000000..bfb23b6d01c29b326221b16245b3e106c66f2182 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/_philox.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.random._philox","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","BitGenerator":{".class":"SymbolTableNode","cross_ref":"numpy.random.bit_generator.BitGenerator","kind":"Gdef","module_hidden":true,"module_public":false},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"Philox":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy.random.bit_generator.BitGenerator"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.random._philox.Philox","name":"Philox","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.random._philox.Philox","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.random._philox","mro":["numpy.random._philox.Philox","numpy.random.bit_generator.BitGenerator","numpy.random.bit_generator._CythonMixin","abc.ABC","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","seed","counter","key"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random._philox.Philox.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","seed","counter","key"],"arg_types":["numpy.random._philox.Philox",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy.random.bit_generator.SeedSequence",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of Philox","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"advance":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","delta"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random._philox.Philox.advance","name":"advance","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","delta"],"arg_types":["numpy.random._philox.Philox","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"advance of Philox","ret_type":"numpy.random._philox.Philox","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"jumped":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","jumps"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random._philox.Philox.jumped","name":"jumped","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","jumps"],"arg_types":["numpy.random._philox.Philox","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"jumped of Philox","ret_type":"numpy.random._philox.Philox","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"state":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":["is_property"],"fullname":"numpy.random._philox.Philox.state","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._philox.Philox.state","name":"state","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random._philox.Philox"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of Philox","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.random._philox._PhiloxState"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_settable_property","is_ready","is_inferred"],"fullname":"numpy.random._philox.Philox.state","name":"state","setter_type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","value"],"arg_types":["numpy.random._philox.Philox",{".class":"TypeAliasType","args":[],"type_ref":"numpy.random._philox._PhiloxState"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of Philox","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random._philox.Philox"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of Philox","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.random._philox._PhiloxState"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated","is_trivial_self"],"fullname":"numpy.random._philox.Philox.state","name":"state","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","value"],"arg_types":["numpy.random._philox.Philox",{".class":"TypeAliasType","args":[],"type_ref":"numpy.random._philox._PhiloxState"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of Philox","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"","name":"state","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","value"],"arg_types":["numpy.random._philox.Philox",{".class":"TypeAliasType","args":[],"type_ref":"numpy.random._philox._PhiloxState"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of Philox","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":1,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random._philox.Philox"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of Philox","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.random._philox._PhiloxState"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random._philox.Philox.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.random._philox.Philox","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"SeedSequence":{".class":"SymbolTableNode","cross_ref":"numpy.random.bit_generator.SeedSequence","kind":"Gdef","module_hidden":true,"module_public":false},"TypedDict":{".class":"SymbolTableNode","cross_ref":"typing.TypedDict","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeInt_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeInt_co","kind":"Gdef","module_hidden":true,"module_public":false},"_PhiloxInternal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.random._philox._PhiloxInternal","name":"_PhiloxInternal","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.random._philox._PhiloxInternal","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.random._philox","mro":["numpy.random._philox._PhiloxInternal","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["counter",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],["key",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}]],"readonly_keys":[],"required_keys":["counter","key"]}}},"_PhiloxState":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.random._philox._PhiloxState","name":"_PhiloxState","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.random._philox._PhiloxState","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.random._philox","mro":["numpy.random._philox._PhiloxState","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["bit_generator","builtins.str"],["state",{".class":"TypeAliasType","args":[],"type_ref":"numpy.random._philox._PhiloxInternal"}],["buffer",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],["buffer_pos","builtins.int"],["has_uint32","builtins.int"],["uinteger","builtins.int"]],"readonly_keys":[],"required_keys":["bit_generator","buffer","buffer_pos","has_uint32","state","uinteger"]}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random._philox.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random._philox.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random._philox.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random._philox.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random._philox.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random._philox.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"type_check_only":{".class":"SymbolTableNode","cross_ref":"typing.type_check_only","kind":"Gdef","module_hidden":true,"module_public":false},"uint64":{".class":"SymbolTableNode","cross_ref":"numpy.uint64","kind":"Gdef","module_hidden":true,"module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/random/_philox.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/_philox.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/_philox.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..457fa82061e6e85968802451bc7fff75973200d7 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/_philox.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[5,4,6,1,3,1,1,1],"dep_prios":[5,5,5,5,5,5,30,30],"dependencies":["numpy.random.bit_generator","numpy._typing","numpy.typing","typing","numpy","builtins","_frozen_importlib","abc"],"hash":"51f08d8c61fa9677cd1d415023a57a4874f4d5fa","id":"numpy.random._philox","ignore_all":true,"interface_hash":"8ae2f806dcf86bcc3b77318631f6302cb6ef1fa6","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/random/_philox.pyi","plugin_data":null,"size":1005,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/_sfc64.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/_sfc64.data.json new file mode 100644 index 0000000000000000000000000000000000000000..484ab9a19281b9394a4f2a42b7587e23d677863b --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/_sfc64.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.random._sfc64","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","BitGenerator":{".class":"SymbolTableNode","cross_ref":"numpy.random.bit_generator.BitGenerator","kind":"Gdef","module_hidden":true,"module_public":false},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"SFC64":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy.random.bit_generator.BitGenerator"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.random._sfc64.SFC64","name":"SFC64","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.random._sfc64.SFC64","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.random._sfc64","mro":["numpy.random._sfc64.SFC64","numpy.random.bit_generator.BitGenerator","numpy.random.bit_generator._CythonMixin","abc.ABC","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","seed"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random._sfc64.SFC64.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","seed"],"arg_types":["numpy.random._sfc64.SFC64",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy.random.bit_generator.SeedSequence",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of SFC64","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"state":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":["is_property"],"fullname":"numpy.random._sfc64.SFC64.state","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random._sfc64.SFC64.state","name":"state","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random._sfc64.SFC64"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of SFC64","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.random._sfc64._SFC64State"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_settable_property","is_ready","is_inferred"],"fullname":"numpy.random._sfc64.SFC64.state","name":"state","setter_type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","value"],"arg_types":["numpy.random._sfc64.SFC64",{".class":"TypeAliasType","args":[],"type_ref":"numpy.random._sfc64._SFC64State"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of SFC64","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random._sfc64.SFC64"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of SFC64","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.random._sfc64._SFC64State"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated","is_trivial_self"],"fullname":"numpy.random._sfc64.SFC64.state","name":"state","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","value"],"arg_types":["numpy.random._sfc64.SFC64",{".class":"TypeAliasType","args":[],"type_ref":"numpy.random._sfc64._SFC64State"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of SFC64","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"","name":"state","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","value"],"arg_types":["numpy.random._sfc64.SFC64",{".class":"TypeAliasType","args":[],"type_ref":"numpy.random._sfc64._SFC64State"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of SFC64","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":1,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random._sfc64.SFC64"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of SFC64","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.random._sfc64._SFC64State"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random._sfc64.SFC64.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.random._sfc64.SFC64","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"SeedSequence":{".class":"SymbolTableNode","cross_ref":"numpy.random.bit_generator.SeedSequence","kind":"Gdef","module_hidden":true,"module_public":false},"TypedDict":{".class":"SymbolTableNode","cross_ref":"typing.TypedDict","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeInt_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeInt_co","kind":"Gdef","module_hidden":true,"module_public":false},"_SFC64Internal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.random._sfc64._SFC64Internal","name":"_SFC64Internal","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.random._sfc64._SFC64Internal","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.random._sfc64","mro":["numpy.random._sfc64._SFC64Internal","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["state",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}]],"readonly_keys":[],"required_keys":["state"]}}},"_SFC64State":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.random._sfc64._SFC64State","name":"_SFC64State","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.random._sfc64._SFC64State","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.random._sfc64","mro":["numpy.random._sfc64._SFC64State","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["bit_generator","builtins.str"],["state",{".class":"TypeAliasType","args":[],"type_ref":"numpy.random._sfc64._SFC64Internal"}],["has_uint32","builtins.int"],["uinteger","builtins.int"]],"readonly_keys":[],"required_keys":["bit_generator","has_uint32","state","uinteger"]}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random._sfc64.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random._sfc64.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random._sfc64.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random._sfc64.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random._sfc64.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random._sfc64.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"type_check_only":{".class":"SymbolTableNode","cross_ref":"typing.type_check_only","kind":"Gdef","module_hidden":true,"module_public":false},"uint64":{".class":"SymbolTableNode","cross_ref":"numpy.uint64","kind":"Gdef","module_hidden":true,"module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/random/_sfc64.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/_sfc64.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/_sfc64.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..ad1b86a3ae66b145efbe298d1703b805b1d83b41 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/_sfc64.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[5,4,1,3,1,1,1],"dep_prios":[5,5,5,5,5,30,30],"dependencies":["numpy.random.bit_generator","numpy._typing","typing","numpy","builtins","_frozen_importlib","abc"],"hash":"096432b1a49fe42d984e7f37d1b9143281221ad7","id":"numpy.random._sfc64","ignore_all":true,"interface_hash":"c04b9debf9a753e502ce1e0cd180060ecb7a8e79","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/random/_sfc64.pyi","plugin_data":null,"size":682,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/bit_generator.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/bit_generator.data.json new file mode 100644 index 0000000000000000000000000000000000000000..fe63f415c8a4f9456d5b3269049da596aa1935e1 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/bit_generator.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.random.bit_generator","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"BitGenerator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy.random.bit_generator._CythonMixin","abc.ABC"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.random.bit_generator.BitGenerator","name":"BitGenerator","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.random.bit_generator.BitGenerator","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.random.bit_generator","mro":["numpy.random.bit_generator.BitGenerator","numpy.random.bit_generator._CythonMixin","abc.ABC","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":[null,"seed"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random.bit_generator.BitGenerator.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":[null,"seed"],"arg_types":["numpy.random.bit_generator.BitGenerator",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy.random.bit_generator.SeedSequence",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of BitGenerator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__reduce__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random.bit_generator.BitGenerator.__reduce__","name":"__reduce__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random.bit_generator.BitGenerator"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__reduce__ of BitGenerator","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy.random.bit_generator.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"TupleType","implicit":false,"items":["builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Mapping"},"numpy.random.bit_generator.ISeedSequence"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_benchmark":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":[null,"cnt","method"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random.bit_generator.BitGenerator._benchmark","name":"_benchmark","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":[null,"cnt","method"],"arg_types":["numpy.random.bit_generator.BitGenerator","builtins.int","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_benchmark of BitGenerator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"capsule":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy.random.bit_generator.BitGenerator.capsule","name":"capsule","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random.bit_generator.BitGenerator"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"capsule of BitGenerator","ret_type":"typing_extensions.CapsuleType","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy.random.bit_generator.BitGenerator.capsule","name":"capsule","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random.bit_generator.BitGenerator"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"capsule of BitGenerator","ret_type":"typing_extensions.CapsuleType","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"cffi":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy.random.bit_generator.BitGenerator.cffi","name":"cffi","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random.bit_generator.BitGenerator"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cffi of BitGenerator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.random.bit_generator._Interface"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy.random.bit_generator.BitGenerator.cffi","name":"cffi","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random.bit_generator.BitGenerator"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cffi of BitGenerator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.random.bit_generator._Interface"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"ctypes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy.random.bit_generator.BitGenerator.ctypes","name":"ctypes","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random.bit_generator.BitGenerator"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ctypes of BitGenerator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.random.bit_generator._Interface"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy.random.bit_generator.BitGenerator.ctypes","name":"ctypes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random.bit_generator.BitGenerator"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ctypes of BitGenerator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.random.bit_generator._Interface"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"lock":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.random.bit_generator.BitGenerator.lock","name":"lock","setter_type":null,"type":"_thread.LockType"}},"random_raw":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.bit_generator.BitGenerator.random_raw","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":[null,"size","output"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.bit_generator.BitGenerator.random_raw","name":"random_raw","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":[null,"size","output"],"arg_types":["numpy.random.bit_generator.BitGenerator",{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random_raw of BitGenerator","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.bit_generator.BitGenerator.random_raw","name":"random_raw","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":[null,"size","output"],"arg_types":["numpy.random.bit_generator.BitGenerator",{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random_raw of BitGenerator","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":[null,"size","output"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.bit_generator.BitGenerator.random_raw","name":"random_raw","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":[null,"size","output"],"arg_types":["numpy.random.bit_generator.BitGenerator",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random_raw of BitGenerator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.bit_generator.BitGenerator.random_raw","name":"random_raw","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":[null,"size","output"],"arg_types":["numpy.random.bit_generator.BitGenerator",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random_raw of BitGenerator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":[null,"size","output"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.bit_generator.BitGenerator.random_raw","name":"random_raw","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"size","output"],"arg_types":["numpy.random.bit_generator.BitGenerator",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random_raw of BitGenerator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.bit_generator.BitGenerator.random_raw","name":"random_raw","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"size","output"],"arg_types":["numpy.random.bit_generator.BitGenerator",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random_raw of BitGenerator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,3],"arg_names":[null,"size","output"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.bit_generator.BitGenerator.random_raw","name":"random_raw","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,3],"arg_names":[null,"size","output"],"arg_types":["numpy.random.bit_generator.BitGenerator",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random_raw of BitGenerator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.bit_generator.BitGenerator.random_raw","name":"random_raw","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,3],"arg_names":[null,"size","output"],"arg_types":["numpy.random.bit_generator.BitGenerator",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random_raw of BitGenerator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":[null,"size","output"],"arg_types":["numpy.random.bit_generator.BitGenerator",{".class":"NoneType"},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random_raw of BitGenerator","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":[null,"size","output"],"arg_types":["numpy.random.bit_generator.BitGenerator",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random_raw of BitGenerator","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,"size","output"],"arg_types":["numpy.random.bit_generator.BitGenerator",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random_raw of BitGenerator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,3],"arg_names":[null,"size","output"],"arg_types":["numpy.random.bit_generator.BitGenerator",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random_raw of BitGenerator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"seed_seq":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy.random.bit_generator.BitGenerator.seed_seq","name":"seed_seq","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random.bit_generator.BitGenerator"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"seed_seq of BitGenerator","ret_type":"numpy.random.bit_generator.ISeedSequence","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy.random.bit_generator.BitGenerator.seed_seq","name":"seed_seq","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random.bit_generator.BitGenerator"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"seed_seq of BitGenerator","ret_type":"numpy.random.bit_generator.ISeedSequence","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"spawn":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"n_children"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random.bit_generator.BitGenerator.spawn","name":"spawn","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"n_children"],"arg_types":["numpy.random.bit_generator.BitGenerator","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"spawn of BitGenerator","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.random.bit_generator.Self","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"state":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":["is_property"],"fullname":"numpy.random.bit_generator.BitGenerator.state","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.bit_generator.BitGenerator.state","name":"state","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random.bit_generator.BitGenerator"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of BitGenerator","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Mapping"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_settable_property","is_ready","is_inferred"],"fullname":"numpy.random.bit_generator.BitGenerator.state","name":"state","setter_type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.random.bit_generator.BitGenerator",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Mapping"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of BitGenerator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random.bit_generator.BitGenerator"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of BitGenerator","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Mapping"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated","is_trivial_self"],"fullname":"numpy.random.bit_generator.BitGenerator.state","name":"state","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.random.bit_generator.BitGenerator",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Mapping"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of BitGenerator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"","name":"state","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.random.bit_generator.BitGenerator",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Mapping"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of BitGenerator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":1,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random.bit_generator.BitGenerator"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of BitGenerator","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Mapping"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random.bit_generator.BitGenerator.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.random.bit_generator.BitGenerator","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef","module_hidden":true,"module_public":false},"CapsuleType":{".class":"SymbolTableNode","cross_ref":"typing_extensions.CapsuleType","kind":"Gdef","module_hidden":true,"module_public":false},"ClassVar":{".class":"SymbolTableNode","cross_ref":"typing.ClassVar","kind":"Gdef","module_hidden":true,"module_public":false},"ISeedSequence":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[["generate_state",1]],"alt_promote":null,"bases":["abc.ABC"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.random.bit_generator.ISeedSequence","name":"ISeedSequence","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_abstract"],"fullname":"numpy.random.bit_generator.ISeedSequence","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.random.bit_generator","mro":["numpy.random.bit_generator.ISeedSequence","abc.ABC","builtins.object"],"names":{".class":"SymbolTable","generate_state":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":1,"arg_kinds":[0,0,1],"arg_names":[null,"n_words","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated","is_trivial_self"],"fullname":"numpy.random.bit_generator.ISeedSequence.generate_state","name":"generate_state","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":[null,"n_words","dtype"],"arg_types":["numpy.random.bit_generator.ISeedSequence","builtins.int",{".class":"AnyType","missing_import_name":"numpy.random.bit_generator.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"generate_state of ISeedSequence","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred"],"fullname":"numpy.random.bit_generator.ISeedSequence.generate_state","name":"generate_state","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":[null,"n_words","dtype"],"arg_types":["numpy.random.bit_generator.ISeedSequence","builtins.int",{".class":"AnyType","missing_import_name":"numpy.random.bit_generator.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"generate_state of ISeedSequence","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random.bit_generator.ISeedSequence.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.random.bit_generator.ISeedSequence","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ISpawnableSeedSequence":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[["generate_state",1],["spawn",1]],"alt_promote":null,"bases":["numpy.random.bit_generator.ISeedSequence","abc.ABC"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.random.bit_generator.ISpawnableSeedSequence","name":"ISpawnableSeedSequence","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_abstract"],"fullname":"numpy.random.bit_generator.ISpawnableSeedSequence","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.random.bit_generator","mro":["numpy.random.bit_generator.ISpawnableSeedSequence","numpy.random.bit_generator.ISeedSequence","abc.ABC","builtins.object"],"names":{".class":"SymbolTable","spawn":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":1,"arg_kinds":[0,0],"arg_names":[null,"n_children"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated","is_trivial_self"],"fullname":"numpy.random.bit_generator.ISpawnableSeedSequence.spawn","name":"spawn","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"n_children"],"arg_types":["numpy.random.bit_generator.ISpawnableSeedSequence","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"spawn of ISpawnableSeedSequence","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.random.bit_generator.Self","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred"],"fullname":"numpy.random.bit_generator.ISpawnableSeedSequence.spawn","name":"spawn","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"n_children"],"arg_types":["numpy.random.bit_generator.ISpawnableSeedSequence","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"spawn of ISpawnableSeedSequence","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.random.bit_generator.Self","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random.bit_generator.ISpawnableSeedSequence.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.random.bit_generator.ISpawnableSeedSequence","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Incomplete":{".class":"SymbolTableNode","cross_ref":"_typeshed.Incomplete","kind":"Gdef","module_hidden":true,"module_public":false},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"Lock":{".class":"SymbolTableNode","cross_ref":"threading.Lock","kind":"Gdef","module_hidden":true,"module_public":false},"Mapping":{".class":"SymbolTableNode","cross_ref":"typing.Mapping","kind":"Gdef","module_hidden":true,"module_public":false},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"NamedTuple":{".class":"SymbolTableNode","cross_ref":"typing.NamedTuple","kind":"Gdef","module_hidden":true,"module_public":false},"SeedSequence":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy.random.bit_generator._GenerateStateMixin","numpy.random.bit_generator.ISpawnableSeedSequence"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.random.bit_generator.SeedSequence","name":"SeedSequence","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.random.bit_generator.SeedSequence","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.random.bit_generator","mro":["numpy.random.bit_generator.SeedSequence","numpy.random.bit_generator._GenerateStateMixin","numpy.random.bit_generator._CythonMixin","numpy.random.bit_generator.ISpawnableSeedSequence","numpy.random.bit_generator.ISeedSequence","abc.ABC","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,5,5,5],"arg_names":[null,"entropy","spawn_key","pool_size","n_children_spawned"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random.bit_generator.SeedSequence.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,5,5,5],"arg_names":[null,"entropy","spawn_key","pool_size","n_children_spawned"],"arg_types":["numpy.random.bit_generator.SeedSequence",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},"builtins.int","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of SeedSequence","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__pyx_vtable__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready","has_explicit_value"],"fullname":"numpy.random.bit_generator.SeedSequence.__pyx_vtable__","name":"__pyx_vtable__","setter_type":null,"type":"typing_extensions.CapsuleType"}},"entropy":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.random.bit_generator.SeedSequence.entropy","name":"entropy","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true}}},"n_children_spawned":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.random.bit_generator.SeedSequence.n_children_spawned","name":"n_children_spawned","setter_type":null,"type":"builtins.int"}},"pool":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.random.bit_generator.SeedSequence.pool","name":"pool","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}}},"pool_size":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.random.bit_generator.SeedSequence.pool_size","name":"pool_size","setter_type":null,"type":"builtins.int"}},"spawn":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"n_children"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random.bit_generator.SeedSequence.spawn","name":"spawn","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"n_children"],"arg_types":["numpy.random.bit_generator.SeedSequence","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"spawn of SeedSequence","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.random.bit_generator.Self","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"spawn_key":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.random.bit_generator.SeedSequence.spawn_key","name":"spawn_key","setter_type":null,"type":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}}},"state":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"numpy.random.bit_generator.SeedSequence.state","name":"state","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random.bit_generator.SeedSequence"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of SeedSequence","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.random.bit_generator._SeedSeqState"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"numpy.random.bit_generator.SeedSequence.state","name":"state","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random.bit_generator.SeedSequence"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"state of SeedSequence","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.random.bit_generator._SeedSeqState"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random.bit_generator.SeedSequence.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.random.bit_generator.SeedSequence","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"SeedlessSeedSequence":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy.random.bit_generator._GenerateStateMixin","numpy.random.bit_generator.ISpawnableSeedSequence"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.random.bit_generator.SeedlessSeedSequence","name":"SeedlessSeedSequence","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.random.bit_generator.SeedlessSeedSequence","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"numpy.random.bit_generator","mro":["numpy.random.bit_generator.SeedlessSeedSequence","numpy.random.bit_generator._GenerateStateMixin","numpy.random.bit_generator._CythonMixin","numpy.random.bit_generator.ISpawnableSeedSequence","numpy.random.bit_generator.ISeedSequence","abc.ABC","builtins.object"],"names":{".class":"SymbolTable","spawn":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"n_children"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random.bit_generator.SeedlessSeedSequence.spawn","name":"spawn","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"n_children"],"arg_types":["numpy.random.bit_generator.SeedlessSeedSequence","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"spawn of SeedlessSeedSequence","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.random.bit_generator.Self","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random.bit_generator.SeedlessSeedSequence.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.random.bit_generator.SeedlessSeedSequence","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Self":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.random.bit_generator.Self","name":"Self","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.random.bit_generator.Self","source_any":null,"type_of_any":3}}},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef","module_hidden":true,"module_public":false},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.random.bit_generator.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.random.bit_generator.TypeAlias","source_any":null,"type_of_any":3}}},"TypedDict":{".class":"SymbolTableNode","cross_ref":"typing.TypedDict","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeInt_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeInt_co","kind":"Gdef","module_hidden":true,"module_public":false},"_CythonMixin":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.random.bit_generator._CythonMixin","name":"_CythonMixin","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.random.bit_generator._CythonMixin","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.random.bit_generator","mro":["numpy.random.bit_generator._CythonMixin","builtins.object"],"names":{".class":"SymbolTable","__reduce_cython__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random.bit_generator._CythonMixin.__reduce_cython__","name":"__reduce_cython__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random.bit_generator._CythonMixin"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__reduce_cython__ of _CythonMixin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__setstate_cython__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random.bit_generator._CythonMixin.__setstate_cython__","name":"__setstate_cython__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["numpy.random.bit_generator._CythonMixin","builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__setstate_cython__ of _CythonMixin","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random.bit_generator._CythonMixin.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.random.bit_generator._CythonMixin","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_DTypeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._DTypeLike","kind":"Gdef","module_hidden":true,"module_public":false},"_DTypeLikeUint_":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.random.bit_generator._DTypeLikeUint_","name":"_DTypeLikeUint_","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.random.bit_generator.TypeAlias","source_any":null,"type_of_any":3}}},"_GenerateStateMixin":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["numpy.random.bit_generator._CythonMixin"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.random.bit_generator._GenerateStateMixin","name":"_GenerateStateMixin","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.random.bit_generator._GenerateStateMixin","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.random.bit_generator","mro":["numpy.random.bit_generator._GenerateStateMixin","numpy.random.bit_generator._CythonMixin","builtins.object"],"names":{".class":"SymbolTable","generate_state":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":[null,"n_words","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random.bit_generator._GenerateStateMixin.generate_state","name":"generate_state","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":[null,"n_words","dtype"],"arg_types":["numpy.random.bit_generator._GenerateStateMixin","builtins.int",{".class":"AnyType","missing_import_name":"numpy.random.bit_generator.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"generate_state of _GenerateStateMixin","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random.bit_generator._GenerateStateMixin.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.random.bit_generator._GenerateStateMixin","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_Interface":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.random.bit_generator._Interface","name":"_Interface","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_named_tuple"],"fullname":"numpy.random.bit_generator._Interface","has_param_spec_type":false,"metaclass_type":null,"metadata":{"namedtuple":{"fields":["state_address","state","next_uint64","next_uint32","next_double","bit_generator"]}},"module_name":"numpy.random.bit_generator","mro":["numpy.random.bit_generator._Interface","builtins.tuple","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","_NT":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random.bit_generator._Interface._NT","name":"_NT","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},"__annotations__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.random.bit_generator._Interface.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.random.bit_generator._Interface.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__new__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0,0,0],"arg_names":["_cls","state_address","state","next_uint64","next_uint32","next_double","bit_generator"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static"],"fullname":"numpy.random.bit_generator._Interface.__new__","name":"__new__","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,0],"arg_names":["_cls","state_address","state","next_uint64","next_uint32","next_double","bit_generator"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random.bit_generator._Interface._NT","id":-1,"name":"_NT","namespace":"numpy.random.bit_generator._Interface.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of _Interface","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random.bit_generator._Interface._NT","id":-1,"name":"_NT","namespace":"numpy.random.bit_generator._Interface.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random.bit_generator._Interface._NT","id":-1,"name":"_NT","namespace":"numpy.random.bit_generator._Interface.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_asdict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["_self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.random.bit_generator._Interface._asdict","name":"_asdict","original_first_arg":"_self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["_self"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random.bit_generator._Interface._NT","id":-1,"name":"_NT","namespace":"numpy.random.bit_generator._Interface._asdict","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_asdict of _Interface","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random.bit_generator._Interface._NT","id":-1,"name":"_NT","namespace":"numpy.random.bit_generator._Interface._asdict","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_field_defaults":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.random.bit_generator._Interface._field_defaults","name":"_field_defaults","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_field_types":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.random.bit_generator._Interface._field_types","name":"_field_types","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_fields":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.random.bit_generator._Interface._fields","name":"_fields","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_make":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["_cls","iterable"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated"],"fullname":"numpy.random.bit_generator._Interface._make","name":"_make","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["_cls","iterable"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random.bit_generator._Interface._NT","id":-1,"name":"_NT","namespace":"numpy.random.bit_generator._Interface._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_make of _Interface","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random.bit_generator._Interface._NT","id":-1,"name":"_NT","namespace":"numpy.random.bit_generator._Interface._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random.bit_generator._Interface._NT","id":-1,"name":"_NT","namespace":"numpy.random.bit_generator._Interface._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_classmethod","is_ready"],"fullname":"numpy.random.bit_generator._Interface._make","name":"_make","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["_cls","iterable"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random.bit_generator._Interface._NT","id":-1,"name":"_NT","namespace":"numpy.random.bit_generator._Interface._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_make of _Interface","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random.bit_generator._Interface._NT","id":-1,"name":"_NT","namespace":"numpy.random.bit_generator._Interface._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random.bit_generator._Interface._NT","id":-1,"name":"_NT","namespace":"numpy.random.bit_generator._Interface._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}}},"plugin_generated":true},"_replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5,5,5],"arg_names":["_self","state_address","state","next_uint64","next_uint32","next_double","bit_generator"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.random.bit_generator._Interface._replace","name":"_replace","original_first_arg":"_self","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5,5,5],"arg_names":["_self","state_address","state","next_uint64","next_uint32","next_double","bit_generator"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random.bit_generator._Interface._NT","id":-1,"name":"_NT","namespace":"numpy.random.bit_generator._Interface._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_replace of _Interface","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random.bit_generator._Interface._NT","id":-1,"name":"_NT","namespace":"numpy.random.bit_generator._Interface._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random.bit_generator._Interface._NT","id":-1,"name":"_NT","namespace":"numpy.random.bit_generator._Interface._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_source":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.random.bit_generator._Interface._source","name":"_source","setter_type":null,"type":"builtins.str"}},"bit_generator":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"numpy.random.bit_generator._Interface.bit_generator","name":"bit_generator","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}}},"bit_generator-redefinition":{".class":"SymbolTableNode","cross_ref":"numpy.random.bit_generator._Interface.bit_generator","kind":"Mdef"},"next_double":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"numpy.random.bit_generator._Interface.next_double","name":"next_double","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}}},"next_double-redefinition":{".class":"SymbolTableNode","cross_ref":"numpy.random.bit_generator._Interface.next_double","kind":"Mdef"},"next_uint32":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"numpy.random.bit_generator._Interface.next_uint32","name":"next_uint32","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}}},"next_uint32-redefinition":{".class":"SymbolTableNode","cross_ref":"numpy.random.bit_generator._Interface.next_uint32","kind":"Mdef"},"next_uint64":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"numpy.random.bit_generator._Interface.next_uint64","name":"next_uint64","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}}},"next_uint64-redefinition":{".class":"SymbolTableNode","cross_ref":"numpy.random.bit_generator._Interface.next_uint64","kind":"Mdef"},"state":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"numpy.random.bit_generator._Interface.state","name":"state","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}}},"state-redefinition":{".class":"SymbolTableNode","cross_ref":"numpy.random.bit_generator._Interface.state","kind":"Mdef"},"state_address":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"numpy.random.bit_generator._Interface.state_address","name":"state_address","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}}},"state_address-redefinition":{".class":"SymbolTableNode","cross_ref":"numpy.random.bit_generator._Interface.state_address","kind":"Mdef"}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random.bit_generator._Interface.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}],"partial_fallback":"numpy.random.bit_generator._Interface"},"values":[],"variance":0},"slots":null,"tuple_type":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.Incomplete"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_vars":[],"typeddict_type":null}},"_SeedSeqState":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.random.bit_generator._SeedSeqState","name":"_SeedSeqState","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.random.bit_generator._SeedSeqState","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.random.bit_generator","mro":["numpy.random.bit_generator._SeedSeqState","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["entropy",{".class":"UnionType","items":["builtins.int",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"NoneType"}],"uses_pep604_syntax":true}],["spawn_key",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}],["pool_size","builtins.int"],["n_children_spawned","builtins.int"]],"readonly_keys":[],"required_keys":["entropy","n_children_spawned","pool_size","spawn_key"]}}},"_ShapeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._shape._ShapeLike","kind":"Gdef","module_hidden":true,"module_public":false},"_UInt32Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._UInt32Codes","kind":"Gdef","module_hidden":true,"module_public":false},"_UInt64Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._UInt64Codes","kind":"Gdef","module_hidden":true,"module_public":false},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.bit_generator.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random.bit_generator.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random.bit_generator.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random.bit_generator.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random.bit_generator.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random.bit_generator.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random.bit_generator.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"abc":{".class":"SymbolTableNode","cross_ref":"abc","kind":"Gdef","module_hidden":true,"module_public":false},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false},"type_check_only":{".class":"SymbolTableNode","cross_ref":"typing.type_check_only","kind":"Gdef","module_hidden":true,"module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/random/bit_generator.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/bit_generator.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/bit_generator.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..52dc6f6c941e3d048d18ad9012d429e698629169 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/bit_generator.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[2,20,1,3,4,16,17,19,1,1,1,1,1],"dep_prios":[5,5,10,5,5,5,5,10,5,30,30,30,30],"dependencies":["collections.abc","numpy._typing","abc","threading","typing","_typeshed","typing_extensions","numpy","builtins","_frozen_importlib","_thread","numpy._typing._char_codes","numpy._typing._dtype_like"],"hash":"6f59c3ca35f5ffa65a229993f78a230d5a2be395","id":"numpy.random.bit_generator","ignore_all":true,"interface_hash":"fa8f61fa6cc1864008c35dec3300b6ae4460c496","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/random/bit_generator.pyi","plugin_data":null,"size":3604,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/mtrand.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/mtrand.data.json new file mode 100644 index 0000000000000000000000000000000000000000..d578795a2f883068de8f58e7a96cbb649a2509a3 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/mtrand.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.random.mtrand","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"BitGenerator":{".class":"SymbolTableNode","cross_ref":"numpy.random.bit_generator.BitGenerator","kind":"Gdef","module_hidden":true,"module_public":false},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef","module_hidden":true,"module_public":false},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"RandomState":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.random.mtrand.RandomState","name":"RandomState","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.random.mtrand","mro":["numpy.random.mtrand.RandomState","builtins.object"],"names":{".class":"SymbolTable","__getstate__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.__getstate__","name":"__getstate__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random.mtrand.RandomState"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getstate__ of RandomState","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","seed"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","seed"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"numpy.random.bit_generator.BitGenerator",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of RandomState","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__reduce__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.__reduce__","name":"__reduce__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random.mtrand.RandomState"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__reduce__ of RandomState","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["numpy.random.bit_generator.BitGenerator"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"numpy.random.mtrand.RandomState","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"TupleType","implicit":false,"items":["numpy.random.bit_generator.BitGenerator"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.__repr__","name":"__repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["numpy.random.mtrand.RandomState"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr__ of RandomState","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__setstate__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","state"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.__setstate__","name":"__setstate__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","state"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__setstate__ of RandomState","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__str__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.__str__","name":"__str__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["numpy.random.mtrand.RandomState"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__str__ of RandomState","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_bit_generator":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"numpy.random.mtrand.RandomState._bit_generator","name":"_bit_generator","setter_type":null,"type":"numpy.random.bit_generator.BitGenerator"}},"beta":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.beta","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","a","b","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.beta","name":"beta","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","a","b","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"beta of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.beta","name":"beta","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","a","b","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"beta of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","a","b","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.beta","name":"beta","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","a","b","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"beta of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.beta","name":"beta","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","a","b","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"beta of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","a","b","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"beta of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","a","b","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"beta of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"binomial":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.binomial","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","n","p","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.binomial","name":"binomial","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","n","p","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"binomial of RandomState","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.binomial","name":"binomial","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","n","p","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"binomial of RandomState","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","n","p","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.binomial","name":"binomial","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","n","p","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"binomial of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.binomial","name":"binomial","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","n","p","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"binomial of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","n","p","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"binomial of RandomState","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","n","p","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"binomial of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"bytes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","length"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.bytes","name":"bytes","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","length"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"bytes of RandomState","ret_type":"builtins.bytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"chisquare":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.chisquare","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","df","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.chisquare","name":"chisquare","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","df","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chisquare of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.chisquare","name":"chisquare","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","df","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chisquare of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","df","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.chisquare","name":"chisquare","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","df","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chisquare of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.chisquare","name":"chisquare","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","df","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chisquare of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","df","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chisquare of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","df","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"chisquare of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"choice":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.choice","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["self","a","size","replace","p"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.choice","name":"choice","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","a","size","replace","p"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"NoneType"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"choice of RandomState","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.choice","name":"choice","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","a","size","replace","p"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"NoneType"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"choice of RandomState","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["self","a","size","replace","p"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.choice","name":"choice","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","a","size","replace","p"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"choice of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.choice","name":"choice","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","a","size","replace","p"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"choice of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["self","a","size","replace","p"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.choice","name":"choice","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","a","size","replace","p"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"choice of RandomState","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.choice","name":"choice","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","a","size","replace","p"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"choice of RandomState","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["self","a","size","replace","p"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.choice","name":"choice","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","a","size","replace","p"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"choice of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.choice","name":"choice","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","a","size","replace","p"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"choice of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","a","size","replace","p"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"NoneType"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"choice of RandomState","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","a","size","replace","p"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"choice of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","a","size","replace","p"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"choice of RandomState","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","a","size","replace","p"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"choice of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"dirichlet":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","alpha","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.dirichlet","name":"dirichlet","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","alpha","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dirichlet of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"exponential":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.exponential","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["self","scale","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.exponential","name":"exponential","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","scale","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"exponential of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.exponential","name":"exponential","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","scale","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"exponential of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["self","scale","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.exponential","name":"exponential","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","scale","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"exponential of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.exponential","name":"exponential","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","scale","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"exponential of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","scale","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"exponential of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","scale","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"exponential of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"f":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.f","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","dfnum","dfden","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.f","name":"f","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","dfnum","dfden","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"f of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.f","name":"f","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","dfnum","dfden","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"f of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","dfnum","dfden","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.f","name":"f","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","dfnum","dfden","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"f of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.f","name":"f","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","dfnum","dfden","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"f of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","dfnum","dfden","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"f of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","dfnum","dfden","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"f of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"gamma":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.gamma","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","shape","scale","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.gamma","name":"gamma","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","shape","scale","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"gamma of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.gamma","name":"gamma","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","shape","scale","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"gamma of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","shape","scale","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.gamma","name":"gamma","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","shape","scale","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"gamma of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.gamma","name":"gamma","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","shape","scale","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"gamma of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","shape","scale","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"gamma of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","shape","scale","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"gamma of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"geometric":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.geometric","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","p","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.geometric","name":"geometric","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","p","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"geometric of RandomState","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.geometric","name":"geometric","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","p","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"geometric of RandomState","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","p","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.geometric","name":"geometric","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","p","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"geometric of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.geometric","name":"geometric","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","p","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"geometric of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","p","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"geometric of RandomState","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","p","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"geometric of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"get_state":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.get_state","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","legacy"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.get_state","name":"get_state","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","legacy"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_state of RandomState","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.get_state","name":"get_state","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","legacy"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_state of RandomState","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","legacy"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.get_state","name":"get_state","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","legacy"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_state of RandomState","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"TupleType","implicit":false,"items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int","builtins.int","builtins.float"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.get_state","name":"get_state","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","legacy"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_state of RandomState","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"TupleType","implicit":false,"items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int","builtins.int","builtins.float"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","legacy"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_state of RandomState","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","legacy"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_state of RandomState","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"TupleType","implicit":false,"items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int","builtins.int","builtins.float"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"gumbel":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.gumbel","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.gumbel","name":"gumbel","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"gumbel of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.gumbel","name":"gumbel","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"gumbel of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.gumbel","name":"gumbel","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"gumbel of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.gumbel","name":"gumbel","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"gumbel of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"gumbel of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"gumbel of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"hypergeometric":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.hypergeometric","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1],"arg_names":["self","ngood","nbad","nsample","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.hypergeometric","name":"hypergeometric","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","ngood","nbad","nsample","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int","builtins.int","builtins.int",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hypergeometric of RandomState","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.hypergeometric","name":"hypergeometric","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","ngood","nbad","nsample","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int","builtins.int","builtins.int",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hypergeometric of RandomState","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1],"arg_names":["self","ngood","nbad","nsample","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.hypergeometric","name":"hypergeometric","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","ngood","nbad","nsample","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hypergeometric of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.hypergeometric","name":"hypergeometric","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","ngood","nbad","nsample","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hypergeometric of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","ngood","nbad","nsample","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int","builtins.int","builtins.int",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hypergeometric of RandomState","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","ngood","nbad","nsample","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hypergeometric of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"laplace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.laplace","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.laplace","name":"laplace","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"laplace of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.laplace","name":"laplace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"laplace of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.laplace","name":"laplace","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"laplace of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.laplace","name":"laplace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"laplace of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"laplace of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"laplace of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"logistic":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.logistic","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.logistic","name":"logistic","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logistic of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.logistic","name":"logistic","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logistic of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.logistic","name":"logistic","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logistic of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.logistic","name":"logistic","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logistic of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logistic of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logistic of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"lognormal":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.lognormal","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","mean","sigma","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.lognormal","name":"lognormal","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","mean","sigma","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lognormal of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.lognormal","name":"lognormal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","mean","sigma","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lognormal of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","mean","sigma","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.lognormal","name":"lognormal","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","mean","sigma","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lognormal of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.lognormal","name":"lognormal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","mean","sigma","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lognormal of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","mean","sigma","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lognormal of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","mean","sigma","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lognormal of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"logseries":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.logseries","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","p","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.logseries","name":"logseries","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","p","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logseries of RandomState","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.logseries","name":"logseries","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","p","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logseries of RandomState","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","p","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.logseries","name":"logseries","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","p","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logseries of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.logseries","name":"logseries","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","p","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logseries of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","p","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logseries of RandomState","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","p","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"logseries of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"multinomial":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","n","pvals","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.multinomial","name":"multinomial","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","n","pvals","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"multinomial of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"multivariate_normal":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1],"arg_names":["self","mean","cov","size","check_valid","tol"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.multivariate_normal","name":"multivariate_normal","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1],"arg_names":["self","mean","cov","size","check_valid","tol"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"warn"},{".class":"LiteralType","fallback":"builtins.str","value":"raise"},{".class":"LiteralType","fallback":"builtins.str","value":"ignore"}],"uses_pep604_syntax":false},"builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"multivariate_normal of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"negative_binomial":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.negative_binomial","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","n","p","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.negative_binomial","name":"negative_binomial","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","n","p","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"negative_binomial of RandomState","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.negative_binomial","name":"negative_binomial","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","n","p","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"negative_binomial of RandomState","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","n","p","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.negative_binomial","name":"negative_binomial","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","n","p","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"negative_binomial of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.negative_binomial","name":"negative_binomial","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","n","p","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"negative_binomial of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","n","p","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"negative_binomial of RandomState","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","n","p","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"negative_binomial of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"noncentral_chisquare":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.noncentral_chisquare","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","df","nonc","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.noncentral_chisquare","name":"noncentral_chisquare","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","df","nonc","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"noncentral_chisquare of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.noncentral_chisquare","name":"noncentral_chisquare","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","df","nonc","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"noncentral_chisquare of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","df","nonc","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.noncentral_chisquare","name":"noncentral_chisquare","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","df","nonc","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"noncentral_chisquare of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.noncentral_chisquare","name":"noncentral_chisquare","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","df","nonc","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"noncentral_chisquare of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","df","nonc","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"noncentral_chisquare of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","df","nonc","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"noncentral_chisquare of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"noncentral_f":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.noncentral_f","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1],"arg_names":["self","dfnum","dfden","nonc","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.noncentral_f","name":"noncentral_f","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","dfnum","dfden","nonc","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"noncentral_f of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.noncentral_f","name":"noncentral_f","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","dfnum","dfden","nonc","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"noncentral_f of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1],"arg_names":["self","dfnum","dfden","nonc","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.noncentral_f","name":"noncentral_f","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","dfnum","dfden","nonc","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"noncentral_f of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.noncentral_f","name":"noncentral_f","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","dfnum","dfden","nonc","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"noncentral_f of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","dfnum","dfden","nonc","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"noncentral_f of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","dfnum","dfden","nonc","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"noncentral_f of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"normal":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.normal","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.normal","name":"normal","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"normal of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.normal","name":"normal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"normal of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.normal","name":"normal","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"normal of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.normal","name":"normal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"normal of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"normal of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","loc","scale","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"normal of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"pareto":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.pareto","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","a","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.pareto","name":"pareto","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pareto of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.pareto","name":"pareto","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pareto of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","a","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.pareto","name":"pareto","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pareto of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.pareto","name":"pareto","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pareto of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pareto of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pareto of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"permutation":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.permutation","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.permutation","name":"permutation","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","x"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"permutation of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.permutation","name":"permutation","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","x"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"permutation of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.permutation","name":"permutation","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","x"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"permutation of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.permutation","name":"permutation","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","x"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"permutation of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","x"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"permutation of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","x"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"permutation of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"poisson":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.poisson","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["self","lam","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.poisson","name":"poisson","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","lam","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"poisson of RandomState","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.poisson","name":"poisson","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","lam","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"poisson of RandomState","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["self","lam","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.poisson","name":"poisson","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","lam","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"poisson of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.poisson","name":"poisson","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","lam","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"poisson of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","lam","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"poisson of RandomState","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","lam","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"poisson of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"power":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.power","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","a","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.power","name":"power","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"power of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.power","name":"power","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"power of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","a","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.power","name":"power","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"power of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.power","name":"power","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"power of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"power of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"power of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"rand":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.rand","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.rand","name":"rand","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random.mtrand.RandomState"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rand of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.rand","name":"rand","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random.mtrand.RandomState"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rand of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2],"arg_names":["self","args"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.rand","name":"rand","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2],"arg_names":["self","args"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rand of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.rand","name":"rand","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,2],"arg_names":["self","args"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rand of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random.mtrand.RandomState"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rand of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,2],"arg_names":["self","args"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rand of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"randint":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.randint","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","low","high","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","low","high","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","low","high","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeType","item":"builtins.bool"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeType","item":"builtins.bool"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeType","item":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeType","item":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeType","item":"builtins.int"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeType","item":"builtins.int"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt8Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt8Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt16Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt16Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt32Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt32Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UIntCodes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UIntCodes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._ULongCodes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._ULongCodes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt64Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt64Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._8Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int8Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._8Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int8Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._16Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int16Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._16Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int16Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._32Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int32Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._32Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int32Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int_"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._nbit.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._IntCodes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int_"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int_"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int_"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._nbit.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._IntCodes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int_"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int_"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.long"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._nbit.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._LongCodes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.long"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.long"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.long"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._nbit.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._LongCodes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.long"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.long"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._64Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int64Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._64Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int64Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","low","high","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","low","high","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","low","high","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._8Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int8Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._8Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int8Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._16Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int16Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._16Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int16Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._32Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int32Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._32Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int32Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._64Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int64Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._64Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int64Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt8Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt8Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt16Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt16Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt32Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt32Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt64Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt64Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.long"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":"builtins.int"},{".class":"TypeType","item":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._nbit.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._LongCodes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.long"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.long"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":"builtins.int"},{".class":"TypeType","item":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._nbit.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._LongCodes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.long"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._ULongCodes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.randint","name":"randint","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._ULongCodes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","low","high","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeType","item":"builtins.bool"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeType","item":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeType","item":"builtins.int"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt8Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt16Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt32Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UIntCodes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._ULongCodes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt64Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._8Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int8Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._16Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int16Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._32Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int32Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int_"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._nbit.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._IntCodes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int_"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int_"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.long"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._nbit.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._LongCodes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.long"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.long"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._64Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int64Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","low","high","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._8Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int8Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._16Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int16Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._32Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int32Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._64Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int64Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt8Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt16Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt32Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt64Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.long"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":"builtins.int"},{".class":"TypeType","item":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._nbit.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._LongCodes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.long"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["self","low","high","size","dtype"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._ULongCodes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"randn":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.randn","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.randn","name":"randn","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random.mtrand.RandomState"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randn of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.randn","name":"randn","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random.mtrand.RandomState"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randn of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2],"arg_names":["self","args"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.randn","name":"randn","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2],"arg_names":["self","args"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randn of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.randn","name":"randn","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,2],"arg_names":["self","args"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randn of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["numpy.random.mtrand.RandomState"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randn of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,2],"arg_names":["self","args"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"randn of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"random":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.random","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.random","name":"random","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.random","name":"random","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.random","name":"random","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.random","name":"random","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"random_integers":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.random_integers","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","low","high","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.random_integers","name":"random_integers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","low","high","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random_integers of RandomState","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.random_integers","name":"random_integers","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","low","high","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random_integers of RandomState","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","low","high","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.random_integers","name":"random_integers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","low","high","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random_integers of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.random_integers","name":"random_integers","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","low","high","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random_integers of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","low","high","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random_integers of RandomState","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","low","high","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random_integers of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"random_sample":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.random_sample","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.random_sample","name":"random_sample","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random_sample of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.random_sample","name":"random_sample","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random_sample of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.random_sample","name":"random_sample","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random_sample of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.random_sample","name":"random_sample","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random_sample of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random_sample of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"random_sample of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"rayleigh":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.rayleigh","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["self","scale","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.rayleigh","name":"rayleigh","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","scale","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rayleigh of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.rayleigh","name":"rayleigh","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","scale","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rayleigh of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["self","scale","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.rayleigh","name":"rayleigh","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","scale","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rayleigh of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.rayleigh","name":"rayleigh","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","scale","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rayleigh of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","scale","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rayleigh of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","scale","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rayleigh of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"seed":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","seed"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.seed","name":"seed","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","seed"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"seed of RandomState","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"set_state":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","state"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.set_state","name":"set_state","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","state"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"TupleType","implicit":false,"items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int","builtins.int","builtins.float"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"set_state of RandomState","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"shuffle":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","x"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.shuffle","name":"shuffle","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","x"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shuffle of RandomState","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"standard_cauchy":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.standard_cauchy","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.standard_cauchy","name":"standard_cauchy","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_cauchy of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.standard_cauchy","name":"standard_cauchy","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_cauchy of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.standard_cauchy","name":"standard_cauchy","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_cauchy of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.standard_cauchy","name":"standard_cauchy","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_cauchy of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_cauchy of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_cauchy of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"standard_exponential":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.standard_exponential","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.standard_exponential","name":"standard_exponential","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_exponential of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.standard_exponential","name":"standard_exponential","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_exponential of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.standard_exponential","name":"standard_exponential","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_exponential of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.standard_exponential","name":"standard_exponential","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_exponential of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_exponential of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_exponential of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"standard_gamma":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.standard_gamma","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","shape","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.standard_gamma","name":"standard_gamma","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","shape","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_gamma of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.standard_gamma","name":"standard_gamma","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","shape","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_gamma of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","shape","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.standard_gamma","name":"standard_gamma","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","shape","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_gamma of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.standard_gamma","name":"standard_gamma","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","shape","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_gamma of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","shape","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_gamma of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","shape","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_gamma of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"standard_normal":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.standard_normal","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.standard_normal","name":"standard_normal","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_normal of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.standard_normal","name":"standard_normal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_normal of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.standard_normal","name":"standard_normal","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_normal of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.standard_normal","name":"standard_normal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_normal of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_normal of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_normal of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"standard_t":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.standard_t","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","df","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.standard_t","name":"standard_t","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","df","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_t of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.standard_t","name":"standard_t","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","df","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_t of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","df","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.standard_t","name":"standard_t","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","df","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_t of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.standard_t","name":"standard_t","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","df","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_t of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","df","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.standard_t","name":"standard_t","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","df","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_t of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.standard_t","name":"standard_t","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","df","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_t of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","df","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_t of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","df","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_t of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","df","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"standard_t of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"tomaxint":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.tomaxint","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.tomaxint","name":"tomaxint","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tomaxint of RandomState","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.tomaxint","name":"tomaxint","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tomaxint of RandomState","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.tomaxint","name":"tomaxint","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tomaxint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.tomaxint","name":"tomaxint","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tomaxint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tomaxint of RandomState","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tomaxint of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"triangular":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.triangular","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1],"arg_names":["self","left","mode","right","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.triangular","name":"triangular","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","left","mode","right","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"triangular of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.triangular","name":"triangular","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","left","mode","right","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"triangular of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1],"arg_names":["self","left","mode","right","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.triangular","name":"triangular","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","left","mode","right","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"triangular of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.triangular","name":"triangular","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","left","mode","right","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"triangular of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","left","mode","right","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"triangular of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","left","mode","right","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"triangular of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"uniform":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.uniform","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","low","high","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.uniform","name":"uniform","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","low","high","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"uniform of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.uniform","name":"uniform","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","low","high","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"uniform of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","low","high","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.uniform","name":"uniform","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","low","high","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"uniform of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.uniform","name":"uniform","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","low","high","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"uniform of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","low","high","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"uniform of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","low","high","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"uniform of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"vonmises":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.vonmises","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","mu","kappa","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.vonmises","name":"vonmises","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","mu","kappa","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vonmises of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.vonmises","name":"vonmises","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","mu","kappa","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vonmises of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","mu","kappa","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.vonmises","name":"vonmises","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","mu","kappa","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vonmises of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.vonmises","name":"vonmises","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","mu","kappa","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vonmises of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","mu","kappa","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vonmises of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","mu","kappa","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"vonmises of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"wald":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.wald","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","mean","scale","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.wald","name":"wald","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","mean","scale","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"wald of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.wald","name":"wald","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","mean","scale","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"wald of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","mean","scale","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.wald","name":"wald","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","mean","scale","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"wald of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.wald","name":"wald","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","mean","scale","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"wald of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","mean","scale","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"wald of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","mean","scale","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"wald of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"weibull":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.weibull","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","a","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.weibull","name":"weibull","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"weibull of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.weibull","name":"weibull","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"weibull of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","a","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.weibull","name":"weibull","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"weibull of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.weibull","name":"weibull","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"weibull of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"weibull of RandomState","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"weibull of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"zipf":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.RandomState.zipf","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","a","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.zipf","name":"zipf","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zipf of RandomState","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.zipf","name":"zipf","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zipf of RandomState","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","a","size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.random.mtrand.RandomState.zipf","name":"zipf","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zipf of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.random.mtrand.RandomState.zipf","name":"zipf","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zipf of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random.mtrand.RandomState","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zipf of RandomState","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","a","size"],"arg_types":["numpy.random.mtrand.RandomState",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"zipf of RandomState","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.random.mtrand.RandomState.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.random.mtrand.RandomState","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_ArrayLikeFloat_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeFloat_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeInt_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeInt_co","kind":"Gdef","module_hidden":true,"module_public":false},"_DTypeLikeBool":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._DTypeLikeBool","kind":"Gdef","module_hidden":true,"module_public":false},"_Int16Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._Int16Codes","kind":"Gdef","module_hidden":true,"module_public":false},"_Int32Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._Int32Codes","kind":"Gdef","module_hidden":true,"module_public":false},"_Int64Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._Int64Codes","kind":"Gdef","module_hidden":true,"module_public":false},"_Int8Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._Int8Codes","kind":"Gdef","module_hidden":true,"module_public":false},"_IntCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._IntCodes","kind":"Gdef","module_hidden":true,"module_public":false},"_LongCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._LongCodes","kind":"Gdef","module_hidden":true,"module_public":false},"_ShapeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._shape._ShapeLike","kind":"Gdef","module_hidden":true,"module_public":false},"_SupportsDType":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like._SupportsDType","kind":"Gdef","module_hidden":true,"module_public":false},"_UInt16Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._UInt16Codes","kind":"Gdef","module_hidden":true,"module_public":false},"_UInt32Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._UInt32Codes","kind":"Gdef","module_hidden":true,"module_public":false},"_UInt64Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._UInt64Codes","kind":"Gdef","module_hidden":true,"module_public":false},"_UInt8Codes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._UInt8Codes","kind":"Gdef","module_hidden":true,"module_public":false},"_UIntCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._UIntCodes","kind":"Gdef","module_hidden":true,"module_public":false},"_ULongCodes":{".class":"SymbolTableNode","cross_ref":"numpy._typing._char_codes._ULongCodes","kind":"Gdef","module_hidden":true,"module_public":false},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random.mtrand.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random.mtrand.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random.mtrand.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random.mtrand.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random.mtrand.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random.mtrand.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_rand":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.random.mtrand._rand","name":"_rand","setter_type":null,"type":"numpy.random.mtrand.RandomState"}},"beta":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.beta","name":"beta","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","size"],"arg_types":["builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["a","b","size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"binomial":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.binomial","name":"binomial","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["n","p","size"],"arg_types":["builtins.int","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["n","p","size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"builtins":{".class":"SymbolTableNode","cross_ref":"builtins","kind":"Gdef","module_hidden":true,"module_public":false},"bytes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.bytes","name":"bytes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["length"],"arg_types":["builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.bytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"chisquare":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.chisquare","name":"chisquare","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["df","size"],"arg_types":["builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["df","size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"choice":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.choice","name":"choice","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","size","replace","p"],"arg_types":["builtins.int",{".class":"NoneType"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","size","replace","p"],"arg_types":["builtins.int",{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","size","replace","p"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["a","size","replace","p"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},"builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"dirichlet":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.dirichlet","name":"dirichlet","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["alpha","size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"dtype":{".class":"SymbolTableNode","cross_ref":"numpy.dtype","kind":"Gdef","module_hidden":true,"module_public":false},"exponential":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.exponential","name":"exponential","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[1,1],"arg_names":["scale","size"],"arg_types":["builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[1,1],"arg_names":["scale","size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"f":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.f","name":"f","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["dfnum","dfden","size"],"arg_types":["builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["dfnum","dfden","size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"float64":{".class":"SymbolTableNode","cross_ref":"numpy.float64","kind":"Gdef","module_hidden":true,"module_public":false},"gamma":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.gamma","name":"gamma","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["shape","scale","size"],"arg_types":["builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["shape","scale","size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"geometric":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.geometric","name":"geometric","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["p","size"],"arg_types":["builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["p","size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"get_bit_generator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.get_bit_generator","name":"get_bit_generator","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_bit_generator","ret_type":"numpy.random.bit_generator.BitGenerator","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_state":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.get_state","name":"get_state","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[1],"arg_names":["legacy"],"arg_types":[{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[1],"arg_names":["legacy"],"arg_types":[{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"TupleType","implicit":false,"items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int","builtins.int","builtins.float"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"gumbel":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.gumbel","name":"gumbel","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[1,1,1],"arg_names":["loc","scale","size"],"arg_types":["builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[1,1,1],"arg_names":["loc","scale","size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"hypergeometric":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.hypergeometric","name":"hypergeometric","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["ngood","nbad","nsample","size"],"arg_types":["builtins.int","builtins.int","builtins.int",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["ngood","nbad","nsample","size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"int16":{".class":"SymbolTableNode","cross_ref":"numpy.int16","kind":"Gdef","module_hidden":true,"module_public":false},"int32":{".class":"SymbolTableNode","cross_ref":"numpy.int32","kind":"Gdef","module_hidden":true,"module_public":false},"int64":{".class":"SymbolTableNode","cross_ref":"numpy.int64","kind":"Gdef","module_hidden":true,"module_public":false},"int8":{".class":"SymbolTableNode","cross_ref":"numpy.int8","kind":"Gdef","module_hidden":true,"module_public":false},"int_":{".class":"SymbolTableNode","cross_ref":"numpy.int_","kind":"Gdef","module_hidden":true,"module_public":false},"laplace":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.laplace","name":"laplace","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[1,1,1],"arg_names":["loc","scale","size"],"arg_types":["builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[1,1,1],"arg_names":["loc","scale","size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"logistic":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.logistic","name":"logistic","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[1,1,1],"arg_names":["loc","scale","size"],"arg_types":["builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[1,1,1],"arg_names":["loc","scale","size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"lognormal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.lognormal","name":"lognormal","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[1,1,1],"arg_names":["mean","sigma","size"],"arg_types":["builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[1,1,1],"arg_names":["mean","sigma","size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"logseries":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.logseries","name":"logseries","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["p","size"],"arg_types":["builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["p","size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"long":{".class":"SymbolTableNode","cross_ref":"numpy.long","kind":"Gdef","module_hidden":true,"module_public":false},"multinomial":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.multinomial","name":"multinomial","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["n","pvals","size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"multivariate_normal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.multivariate_normal","name":"multivariate_normal","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["mean","cov","size","check_valid","tol"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"warn"},{".class":"LiteralType","fallback":"builtins.str","value":"raise"},{".class":"LiteralType","fallback":"builtins.str","value":"ignore"}],"uses_pep604_syntax":false},"builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"negative_binomial":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.negative_binomial","name":"negative_binomial","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["n","p","size"],"arg_types":["builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["n","p","size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"noncentral_chisquare":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.noncentral_chisquare","name":"noncentral_chisquare","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["df","nonc","size"],"arg_types":["builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["df","nonc","size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"noncentral_f":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.noncentral_f","name":"noncentral_f","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["dfnum","dfden","nonc","size"],"arg_types":["builtins.float","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["dfnum","dfden","nonc","size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"normal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.normal","name":"normal","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[1,1,1],"arg_names":["loc","scale","size"],"arg_types":["builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[1,1,1],"arg_names":["loc","scale","size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false},"pareto":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.pareto","name":"pareto","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","size"],"arg_types":["builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"permutation":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.permutation","name":"permutation","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":["builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"poisson":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.poisson","name":"poisson","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[1,1],"arg_names":["lam","size"],"arg_types":["builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[1,1],"arg_names":["lam","size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"power":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.power","name":"power","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","size"],"arg_types":["builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"rand":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.rand","name":"rand","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[2],"arg_names":["args"],"arg_types":["builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"randint":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.randint","name":"randint","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["low","high","size"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["low","high","size","dtype"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeType","item":"builtins.bool"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["low","high","size","dtype"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeType","item":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":["builtins.bool"],"extra_attrs":null,"type_ref":"numpy.bool"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["low","high","size","dtype"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"TypeType","item":"builtins.int"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["low","high","size","dtype"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt8Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["low","high","size","dtype"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt16Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["low","high","size","dtype"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt32Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["low","high","size","dtype"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UIntCodes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["low","high","size","dtype"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._ULongCodes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["low","high","size","dtype"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt64Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["low","high","size","dtype"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._8Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int8Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["low","high","size","dtype"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._16Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int16Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["low","high","size","dtype"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._32Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int32Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["low","high","size","dtype"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int_"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._nbit.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._IntCodes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int_"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int_"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["low","high","size","dtype"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.long"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._nbit.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._LongCodes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.long"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.long"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["low","high","size","dtype"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._64Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int64Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["low","high","size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["low","high","size","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["low","high","size","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._8Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int8Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int8"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["low","high","size","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._16Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int16Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int16"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["low","high","size","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._32Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int32Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int32"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["low","high","size","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"Instance","args":["numpy._typing._nbit_base._64Bit"],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._Int64Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.int64"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["low","high","size","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt8Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["low","high","size","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt16Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["low","high","size","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt32Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["low","high","size","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._UInt64Codes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["low","high","size","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.long"}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":"builtins.int"},{".class":"TypeType","item":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy._typing._nbit.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.signedinteger"}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._LongCodes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"numpy.long"}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["low","high","size","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}},{".class":"TypeAliasType","args":[],"type_ref":"numpy._typing._char_codes._ULongCodes"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.dtype"}],"extra_attrs":null,"type_ref":"numpy._typing._dtype_like._SupportsDType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"randn":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.randn","name":"randn","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[2],"arg_names":["args"],"arg_types":["builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"random":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.random","name":"random","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[1],"arg_names":["size"],"arg_types":[{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"random_integers":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.random_integers","name":"random_integers","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["low","high","size"],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["low","high","size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"random_sample":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.random_sample","name":"random_sample","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[1],"arg_names":["size"],"arg_types":[{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"ranf":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.ranf","name":"ranf","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[1],"arg_names":["size"],"arg_types":[{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"rayleigh":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.rayleigh","name":"rayleigh","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[1,1],"arg_names":["scale","size"],"arg_types":["builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[1,1],"arg_names":["scale","size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"sample":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.sample","name":"sample","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[1],"arg_names":["size"],"arg_types":[{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"seed":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.seed","name":"seed","setter_type":null,"type":{".class":"CallableType","arg_kinds":[1],"arg_names":["seed"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"set_bit_generator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["bitgen"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.random.mtrand.set_bit_generator","name":"set_bit_generator","original_first_arg":"bitgen","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["bitgen"],"arg_types":["numpy.random.bit_generator.BitGenerator"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"set_bit_generator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"set_state":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.set_state","name":"set_state","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["state"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"TupleType","implicit":false,"items":["builtins.str",{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.int","builtins.int","builtins.float"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"shuffle":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.shuffle","name":"shuffle","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"standard_cauchy":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.standard_cauchy","name":"standard_cauchy","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[1],"arg_names":["size"],"arg_types":[{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[1],"arg_names":["size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"standard_exponential":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.standard_exponential","name":"standard_exponential","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[1],"arg_names":["size"],"arg_types":[{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"standard_gamma":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.standard_gamma","name":"standard_gamma","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["shape","size"],"arg_types":["builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["shape","size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"standard_normal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.standard_normal","name":"standard_normal","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[1],"arg_names":["size"],"arg_types":[{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[1],"arg_names":["size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"standard_t":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.standard_t","name":"standard_t","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["df","size"],"arg_types":["builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["df","size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["df","size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"triangular":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.triangular","name":"triangular","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["left","mode","right","size"],"arg_types":["builtins.float","builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["left","mode","right","size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"uint":{".class":"SymbolTableNode","cross_ref":"numpy.uint","kind":"Gdef","module_hidden":true,"module_public":false},"uint16":{".class":"SymbolTableNode","cross_ref":"numpy.uint16","kind":"Gdef","module_hidden":true,"module_public":false},"uint32":{".class":"SymbolTableNode","cross_ref":"numpy.uint32","kind":"Gdef","module_hidden":true,"module_public":false},"uint64":{".class":"SymbolTableNode","cross_ref":"numpy.uint64","kind":"Gdef","module_hidden":true,"module_public":false},"uint8":{".class":"SymbolTableNode","cross_ref":"numpy.uint8","kind":"Gdef","module_hidden":true,"module_public":false},"ulong":{".class":"SymbolTableNode","cross_ref":"numpy.ulong","kind":"Gdef","module_hidden":true,"module_public":false},"uniform":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.uniform","name":"uniform","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[1,1,1],"arg_names":["low","high","size"],"arg_types":["builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[1,1,1],"arg_names":["low","high","size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"vonmises":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.vonmises","name":"vonmises","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["mu","kappa","size"],"arg_types":["builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["mu","kappa","size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"wald":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.wald","name":"wald","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["mean","scale","size"],"arg_types":["builtins.float","builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["mean","scale","size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"weibull":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.weibull","name":"weibull","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","size"],"arg_types":["builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"zipf":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.random.mtrand.zipf","name":"zipf","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","size"],"arg_types":["builtins.float",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["a","size"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._shape.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/random/mtrand.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/mtrand.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/mtrand.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..d57bd5582d103118531b7fe47e83caacc85ff756 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/random/mtrand.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[43,2,22,1,3,5,1,1,1,1],"dep_prios":[5,5,5,10,5,5,30,30,30,30],"dependencies":["numpy.random.bit_generator","collections.abc","numpy._typing","builtins","typing","numpy","_frozen_importlib","abc","numpy._typing._dtype_like","numpy._typing._nbit_base"],"hash":"cbecd721f59e0d6ea9f91fdfc9acc7f9dcdcb81d","id":"numpy.random.mtrand","ignore_all":true,"interface_hash":"4d58ff0f4106a4caba1df463e73bb2ceeb843af6","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/random/mtrand.pyi","plugin_data":null,"size":22687,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/rec/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/rec/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..65a3d63b84c626d7b30202e9c2b4eba0f74478c9 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/rec/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.rec","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.rec.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.rec.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.rec.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.rec.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.rec.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.rec.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.rec.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.rec.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"array":{".class":"SymbolTableNode","cross_ref":"numpy._core.records.array","kind":"Gdef"},"find_duplicate":{".class":"SymbolTableNode","cross_ref":"numpy._core.records.find_duplicate","kind":"Gdef"},"format_parser":{".class":"SymbolTableNode","cross_ref":"numpy._core.records.format_parser","kind":"Gdef"},"fromarrays":{".class":"SymbolTableNode","cross_ref":"numpy._core.records.fromarrays","kind":"Gdef"},"fromfile":{".class":"SymbolTableNode","cross_ref":"numpy._core.records.fromfile","kind":"Gdef"},"fromrecords":{".class":"SymbolTableNode","cross_ref":"numpy._core.records.fromrecords","kind":"Gdef"},"fromstring":{".class":"SymbolTableNode","cross_ref":"numpy._core.records.fromstring","kind":"Gdef"},"recarray":{".class":"SymbolTableNode","cross_ref":"numpy._core.records.recarray","kind":"Gdef"},"record":{".class":"SymbolTableNode","cross_ref":"numpy._core.records.record","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/rec/__init__.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/rec/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/rec/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..25139f2ec3ac7a6721ae7a6339a99704bf6e0b6a --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/rec/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,1,1,1,1],"dep_prios":[5,5,30,30,30],"dependencies":["numpy._core.records","builtins","_frozen_importlib","abc","typing"],"hash":"343dadca2f6c9d74c938a2715b5221f65f37ba2b","id":"numpy.rec","ignore_all":true,"interface_hash":"27dae7849320ddd155060b7ecb33c39053ef43a5","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/rec/__init__.pyi","plugin_data":null,"size":347,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/strings/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/strings/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..af93746979664816175cf916c9922d5bf6f9f644 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/strings/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.strings","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.strings.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.strings.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.strings.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.strings.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.strings.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.strings.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.strings.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.strings.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"add":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.add","kind":"Gdef"},"capitalize":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.capitalize","kind":"Gdef"},"center":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.center","kind":"Gdef"},"count":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.count","kind":"Gdef"},"decode":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.decode","kind":"Gdef"},"encode":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.encode","kind":"Gdef"},"endswith":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.endswith","kind":"Gdef"},"equal":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.equal","kind":"Gdef"},"expandtabs":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.expandtabs","kind":"Gdef"},"find":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.find","kind":"Gdef"},"greater":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.greater","kind":"Gdef"},"greater_equal":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.greater_equal","kind":"Gdef"},"index":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.index","kind":"Gdef"},"isalnum":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.isalnum","kind":"Gdef"},"isalpha":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.isalpha","kind":"Gdef"},"isdecimal":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.isdecimal","kind":"Gdef"},"isdigit":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.isdigit","kind":"Gdef"},"islower":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.islower","kind":"Gdef"},"isnumeric":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.isnumeric","kind":"Gdef"},"isspace":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.isspace","kind":"Gdef"},"istitle":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.istitle","kind":"Gdef"},"isupper":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.isupper","kind":"Gdef"},"less":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.less","kind":"Gdef"},"less_equal":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.less_equal","kind":"Gdef"},"ljust":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.ljust","kind":"Gdef"},"lower":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.lower","kind":"Gdef"},"lstrip":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.lstrip","kind":"Gdef"},"mod":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.mod","kind":"Gdef"},"multiply":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.multiply","kind":"Gdef"},"not_equal":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.not_equal","kind":"Gdef"},"partition":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.partition","kind":"Gdef"},"replace":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.replace","kind":"Gdef"},"rfind":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.rfind","kind":"Gdef"},"rindex":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.rindex","kind":"Gdef"},"rjust":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.rjust","kind":"Gdef"},"rpartition":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.rpartition","kind":"Gdef"},"rstrip":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.rstrip","kind":"Gdef"},"slice":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.slice","kind":"Gdef"},"startswith":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.startswith","kind":"Gdef"},"str_len":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.str_len","kind":"Gdef"},"strip":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.strip","kind":"Gdef"},"swapcase":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.swapcase","kind":"Gdef"},"title":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.title","kind":"Gdef"},"translate":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.translate","kind":"Gdef"},"upper":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.upper","kind":"Gdef"},"zfill":{".class":"SymbolTableNode","cross_ref":"numpy._core.strings.zfill","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/strings/__init__.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/strings/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/strings/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..2b68283ef2ecf86384113f11ac322ee023bae278 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/strings/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,1,1,1,1],"dep_prios":[5,5,30,30,30],"dependencies":["numpy._core.strings","builtins","_frozen_importlib","abc","typing"],"hash":"5d4b6edcc71ad69094983abc8f28fa2209224f7a","id":"numpy.strings","ignore_all":true,"interface_hash":"81ed38892c00babd02d455f9327ef816ad9c4199","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/strings/__init__.pyi","plugin_data":null,"size":1319,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/testing/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/testing/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..be3b874aa050cd1146f7987c390fcbc8b57748e7 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/testing/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.testing","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","HAS_LAPACK64":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.HAS_LAPACK64","kind":"Gdef"},"HAS_REFCOUNT":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.HAS_REFCOUNT","kind":"Gdef"},"IS_EDITABLE":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.IS_EDITABLE","kind":"Gdef"},"IS_INSTALLED":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.IS_INSTALLED","kind":"Gdef"},"IS_MUSL":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.IS_MUSL","kind":"Gdef"},"IS_PYPY":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.IS_PYPY","kind":"Gdef"},"IS_PYSTON":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.IS_PYSTON","kind":"Gdef"},"IS_WASM":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.IS_WASM","kind":"Gdef"},"IgnoreException":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.IgnoreException","kind":"Gdef"},"KnownFailureException":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.KnownFailureException","kind":"Gdef"},"NOGIL_BUILD":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.NOGIL_BUILD","kind":"Gdef"},"NUMPY_ROOT":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.NUMPY_ROOT","kind":"Gdef"},"SkipTest":{".class":"SymbolTableNode","cross_ref":"unittest.case.SkipTest","kind":"Gdef"},"TestCase":{".class":"SymbolTableNode","cross_ref":"unittest.case.TestCase","kind":"Gdef"},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.testing.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.testing.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.testing.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.testing.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.testing.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.testing.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.testing.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.testing.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"assert_":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.assert_","kind":"Gdef"},"assert_allclose":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.assert_allclose","kind":"Gdef"},"assert_almost_equal":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.assert_almost_equal","kind":"Gdef"},"assert_approx_equal":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.assert_approx_equal","kind":"Gdef"},"assert_array_almost_equal":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.assert_array_almost_equal","kind":"Gdef"},"assert_array_almost_equal_nulp":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.assert_array_almost_equal_nulp","kind":"Gdef"},"assert_array_compare":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.assert_array_compare","kind":"Gdef"},"assert_array_equal":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.assert_array_equal","kind":"Gdef"},"assert_array_less":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.assert_array_less","kind":"Gdef"},"assert_array_max_ulp":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.assert_array_max_ulp","kind":"Gdef"},"assert_equal":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.assert_equal","kind":"Gdef"},"assert_no_gc_cycles":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.assert_no_gc_cycles","kind":"Gdef"},"assert_no_warnings":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.assert_no_warnings","kind":"Gdef"},"assert_raises":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.assert_raises","kind":"Gdef"},"assert_raises_regex":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.assert_raises_regex","kind":"Gdef"},"assert_string_equal":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.assert_string_equal","kind":"Gdef"},"assert_warns":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.assert_warns","kind":"Gdef"},"break_cycles":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.break_cycles","kind":"Gdef"},"build_err_msg":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.build_err_msg","kind":"Gdef"},"check_support_sve":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.check_support_sve","kind":"Gdef"},"clear_and_catch_warnings":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.clear_and_catch_warnings","kind":"Gdef"},"decorate_methods":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.decorate_methods","kind":"Gdef"},"jiffies":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.jiffies","kind":"Gdef"},"measure":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.measure","kind":"Gdef"},"memusage":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.memusage","kind":"Gdef"},"overrides":{".class":"SymbolTableNode","cross_ref":"numpy.testing.overrides","kind":"Gdef"},"print_assert_equal":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.print_assert_equal","kind":"Gdef"},"run_threaded":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.run_threaded","kind":"Gdef"},"rundocs":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.rundocs","kind":"Gdef"},"runstring":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.runstring","kind":"Gdef"},"suppress_warnings":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.suppress_warnings","kind":"Gdef"},"tempdir":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.tempdir","kind":"Gdef"},"temppath":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.temppath","kind":"Gdef"},"verbose":{".class":"SymbolTableNode","cross_ref":"numpy.testing._private.utils.verbose","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/testing/__init__.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/testing/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/testing/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..28679259d2b119cc1331627796f07e8cedab32e9 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/testing/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[4,3,1,1,1,1,1],"dep_prios":[5,10,5,5,30,30,30],"dependencies":["numpy.testing._private.utils","numpy.testing.overrides","unittest","builtins","_frozen_importlib","abc","typing"],"hash":"cab5b059ea1e781156b96922364114553dee6db5","id":"numpy.testing","ignore_all":true,"interface_hash":"1e04f3070be654055f5ed3a98dc0896602a47649","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/testing/__init__.pyi","plugin_data":null,"size":2045,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/testing/_private/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/testing/_private/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..5560775e4900cb25bb924cd57727a81430d61d3e --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/testing/_private/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.testing._private","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.testing._private.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.testing._private.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.testing._private.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.testing._private.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.testing._private.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.testing._private.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.testing._private.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/testing/_private/__init__.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/testing/_private/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/testing/_private/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..c02a6157a03ee50ee8bf97e2699f48c7187a525d --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/testing/_private/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106713,"dep_lines":[1,1,1,1],"dep_prios":[5,30,30,30],"dependencies":["builtins","_frozen_importlib","abc","typing"],"hash":"da39a3ee5e6b4b0d3255bfef95601890afd80709","id":"numpy.testing._private","ignore_all":true,"interface_hash":"2d6e5d8381bb77b09ec01eb8a9988b15d4e9fb31","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/testing/_private/__init__.pyi","plugin_data":null,"size":0,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/testing/_private/utils.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/testing/_private/utils.data.json new file mode 100644 index 0000000000000000000000000000000000000000..bf14d9d60d8dad408c54eadb62239ecc3f2fd7ef --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/testing/_private/utils.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.testing._private.utils","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"AnyStr":{".class":"SymbolTableNode","cross_ref":"typing.AnyStr","kind":"Gdef","module_hidden":true,"module_public":false},"ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.ArrayLike","kind":"Gdef","module_hidden":true,"module_public":false},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef","module_hidden":true,"module_public":false},"ClassVar":{".class":"SymbolTableNode","cross_ref":"typing.ClassVar","kind":"Gdef","module_hidden":true,"module_public":false},"ConvertibleToFloat":{".class":"SymbolTableNode","cross_ref":"_typeshed.ConvertibleToFloat","kind":"Gdef","module_hidden":true,"module_public":false},"DTypeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like.DTypeLike","kind":"Gdef","module_hidden":true,"module_public":false},"Final":{".class":"SymbolTableNode","cross_ref":"typing.Final","kind":"Gdef","module_hidden":true,"module_public":false},"Generic":{".class":"SymbolTableNode","cross_ref":"typing.Generic","kind":"Gdef","module_hidden":true,"module_public":false},"GenericPath":{".class":"SymbolTableNode","cross_ref":"_typeshed.GenericPath","kind":"Gdef","module_hidden":true,"module_public":false},"HAS_LAPACK64":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.testing._private.utils.HAS_LAPACK64","name":"HAS_LAPACK64","setter_type":null,"type":"builtins.bool"}},"HAS_REFCOUNT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.testing._private.utils.HAS_REFCOUNT","name":"HAS_REFCOUNT","setter_type":null,"type":"builtins.bool"}},"IS_EDITABLE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.testing._private.utils.IS_EDITABLE","name":"IS_EDITABLE","setter_type":null,"type":"builtins.bool"}},"IS_INSTALLED":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.testing._private.utils.IS_INSTALLED","name":"IS_INSTALLED","setter_type":null,"type":"builtins.bool"}},"IS_MUSL":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.testing._private.utils.IS_MUSL","name":"IS_MUSL","setter_type":null,"type":"builtins.bool"}},"IS_PYPY":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.testing._private.utils.IS_PYPY","name":"IS_PYPY","setter_type":null,"type":"builtins.bool"}},"IS_PYSTON":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.testing._private.utils.IS_PYSTON","name":"IS_PYSTON","setter_type":null,"type":"builtins.bool"}},"IS_WASM":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.testing._private.utils.IS_WASM","name":"IS_WASM","setter_type":null,"type":"builtins.bool"}},"IgnoreException":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.Exception"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.testing._private.utils.IgnoreException","name":"IgnoreException","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils.IgnoreException","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.testing._private.utils","mro":["numpy.testing._private.utils.IgnoreException","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.testing._private.utils.IgnoreException.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.testing._private.utils.IgnoreException","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef","module_hidden":true,"module_public":false},"KnownFailureException":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.Exception"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.testing._private.utils.KnownFailureException","name":"KnownFailureException","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils.KnownFailureException","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.testing._private.utils","mro":["numpy.testing._private.utils.KnownFailureException","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.testing._private.utils.KnownFailureException.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.testing._private.utils.KnownFailureException","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"L":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_hidden":true,"module_public":false},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef","module_hidden":true,"module_public":false},"NOGIL_BUILD":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.testing._private.utils.NOGIL_BUILD","name":"NOGIL_BUILD","setter_type":null,"type":"builtins.bool"}},"NUMPY_ROOT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"numpy.testing._private.utils.NUMPY_ROOT","name":"NUMPY_ROOT","setter_type":null,"type":"pathlib.Path"}},"NoReturn":{".class":"SymbolTableNode","cross_ref":"typing.NoReturn","kind":"Gdef","module_hidden":true,"module_public":false},"ParamSpec":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.testing._private.utils.ParamSpec","name":"ParamSpec","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.ParamSpec","source_any":null,"type_of_any":3}}},"Path":{".class":"SymbolTableNode","cross_ref":"pathlib.Path","kind":"Gdef","module_hidden":true,"module_public":false},"Pattern":{".class":"SymbolTableNode","cross_ref":"re.Pattern","kind":"Gdef","module_hidden":true,"module_public":false},"Self":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.testing._private.utils.Self","name":"Self","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.Self","source_any":null,"type_of_any":3}}},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef","module_hidden":true,"module_public":false},"SkipTest":{".class":"SymbolTableNode","cross_ref":"unittest.case.SkipTest","kind":"Gdef"},"StrOrBytesPath":{".class":"SymbolTableNode","cross_ref":"_typeshed.StrOrBytesPath","kind":"Gdef","module_hidden":true,"module_public":false},"StrPath":{".class":"SymbolTableNode","cross_ref":"_typeshed.StrPath","kind":"Gdef","module_hidden":true,"module_public":false},"SupportsIndex":{".class":"SymbolTableNode","cross_ref":"typing.SupportsIndex","kind":"Gdef","module_hidden":true,"module_public":false},"TypeAlias":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.testing._private.utils.TypeAlias","name":"TypeAlias","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3}}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing_extensions.TypeVar","kind":"Gdef","module_hidden":true,"module_public":false},"TypeVarTuple":{".class":"SymbolTableNode","kind":"Gdef","module_hidden":true,"module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"numpy.testing._private.utils.TypeVarTuple","name":"TypeVarTuple","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeVarTuple","source_any":null,"type_of_any":3}}},"_ArrayLikeDT64_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeDT64_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeNumber_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeNumber_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeObject_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeObject_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ArrayLikeTD64_co":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like._ArrayLikeTD64_co","kind":"Gdef","module_hidden":true,"module_public":false},"_ComparisonFunc":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.testing._private.utils._ComparisonFunc","name":"_ComparisonFunc","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3}}},"_ET":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":"builtins.BaseException","fullname":"numpy.testing._private.utils._ET","name":"_ET","upper_bound":"builtins.BaseException","values":[],"variance":0}},"_ExceptionSpec":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.testing._private.utils._ExceptionSpec","name":"_ExceptionSpec","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3}}},"_FT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.testing._private.utils._FT","name":"_FT","upper_bound":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"values":[],"variance":0}},"_GeneratorContextManager":{".class":"SymbolTableNode","cross_ref":"contextlib._GeneratorContextManager","kind":"Gdef","module_hidden":true,"module_public":false},"_NumericArrayLike":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.testing._private.utils._NumericArrayLike","name":"_NumericArrayLike","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3}}},"_RegexLike":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.testing._private.utils._RegexLike","name":"_RegexLike","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3}}},"_StrLike":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.testing._private.utils._StrLike","name":"_StrLike","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3}}},"_T":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.testing._private.utils._T","name":"_T","upper_bound":"builtins.object","values":[],"variance":0}},"_T_or_bool":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":"builtins.bool","fullname":"numpy.testing._private.utils._T_or_bool","name":"_T_or_bool","upper_bound":"builtins.object","values":[],"variance":0}},"_ToModules":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.testing._private.utils._ToModules","name":"_ToModules","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3}}},"_Ts":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.testing._private.utils._Ts","name":"_Ts","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeVarTuple","source_any":{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeVarTuple","source_any":null,"type_of_any":3},"type_of_any":7}}},"_Tss":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.testing._private.utils._Tss","name":"_Tss","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.ParamSpec","source_any":{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.ParamSpec","source_any":null,"type_of_any":3},"type_of_any":7}}},"_W_co":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.testing._private.utils._W_co","name":"_W_co","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}},"_WarnLog":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.testing._private.utils._WarnLog","name":"_WarnLog","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3}}},"_WarningSpec":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.testing._private.utils._WarningSpec","name":"_WarningSpec","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3}}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.testing._private.utils.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.testing._private.utils.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.testing._private.utils.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.testing._private.utils.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.testing._private.utils.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.testing._private.utils.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.testing._private.utils.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_clear_and_catch_warnings_with_records":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.testing._private.utils.clear_and_catch_warnings"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.testing._private.utils._clear_and_catch_warnings_with_records","name":"_clear_and_catch_warnings_with_records","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils._clear_and_catch_warnings_with_records","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.testing._private.utils","mro":["numpy.testing._private.utils._clear_and_catch_warnings_with_records","numpy.testing._private.utils.clear_and_catch_warnings","warnings.catch_warnings","builtins.object"],"names":{".class":"SymbolTable","__enter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.testing._private.utils._clear_and_catch_warnings_with_records.__enter__","name":"__enter__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["numpy.testing._private.utils._clear_and_catch_warnings_with_records"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__enter__ of _clear_and_catch_warnings_with_records","ret_type":{".class":"Instance","args":["warnings.WarningMessage"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.testing._private.utils._clear_and_catch_warnings_with_records.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.testing._private.utils._clear_and_catch_warnings_with_records","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_clear_and_catch_warnings_without_records":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"numpy.testing._private.utils.clear_and_catch_warnings"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.testing._private.utils._clear_and_catch_warnings_without_records","name":"_clear_and_catch_warnings_without_records","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils._clear_and_catch_warnings_without_records","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.testing._private.utils","mro":["numpy.testing._private.utils._clear_and_catch_warnings_without_records","numpy.testing._private.utils.clear_and_catch_warnings","warnings.catch_warnings","builtins.object"],"names":{".class":"SymbolTable","__enter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.testing._private.utils._clear_and_catch_warnings_without_records.__enter__","name":"__enter__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["numpy.testing._private.utils._clear_and_catch_warnings_without_records"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__enter__ of _clear_and_catch_warnings_without_records","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.testing._private.utils._clear_and_catch_warnings_without_records.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.testing._private.utils._clear_and_catch_warnings_without_records","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"assert_":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["val","msg"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils.assert_","name":"assert_","original_first_arg":"val","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["val","msg"],"arg_types":["builtins.object",{".class":"UnionType","items":["builtins.str",{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"assert_allclose":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils.assert_allclose","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,5],"arg_names":["actual","desired","rtol","atol","equal_nan","err_msg","verbose","strict"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.testing._private.utils.assert_allclose","name":"assert_allclose","original_first_arg":"actual","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5],"arg_names":["actual","desired","rtol","atol","equal_nan","err_msg","verbose","strict"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.float","builtins.float","builtins.bool","builtins.object","builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_allclose","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.testing._private.utils.assert_allclose","name":"assert_allclose","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5],"arg_names":["actual","desired","rtol","atol","equal_nan","err_msg","verbose","strict"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.float","builtins.float","builtins.bool","builtins.object","builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_allclose","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1,5],"arg_names":["actual","desired","rtol","atol","equal_nan","err_msg","verbose","strict"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.testing._private.utils.assert_allclose","name":"assert_allclose","original_first_arg":"actual","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5],"arg_names":["actual","desired","rtol","atol","equal_nan","err_msg","verbose","strict"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},"builtins.float","builtins.float","builtins.bool","builtins.object","builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_allclose","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.testing._private.utils.assert_allclose","name":"assert_allclose","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5],"arg_names":["actual","desired","rtol","atol","equal_nan","err_msg","verbose","strict"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},"builtins.float","builtins.float","builtins.bool","builtins.object","builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_allclose","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5],"arg_names":["actual","desired","rtol","atol","equal_nan","err_msg","verbose","strict"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.float","builtins.float","builtins.bool","builtins.object","builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_allclose","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1,5],"arg_names":["actual","desired","rtol","atol","equal_nan","err_msg","verbose","strict"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},"builtins.float","builtins.float","builtins.bool","builtins.object","builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_allclose","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"assert_almost_equal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["actual","desired","decimal","err_msg","verbose"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils.assert_almost_equal","name":"assert_almost_equal","original_first_arg":"actual","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["actual","desired","decimal","err_msg","verbose"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},"builtins.int","builtins.object","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_almost_equal","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"assert_approx_equal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["actual","desired","significant","err_msg","verbose"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils.assert_approx_equal","name":"assert_approx_equal","original_first_arg":"actual","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["actual","desired","significant","err_msg","verbose"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.ConvertibleToFloat"},{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.ConvertibleToFloat"},"builtins.int","builtins.object","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_approx_equal","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"assert_array_almost_equal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1],"arg_names":["actual","desired","decimal","err_msg","verbose"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils.assert_array_almost_equal","name":"assert_array_almost_equal","original_first_arg":"actual","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["actual","desired","decimal","err_msg","verbose"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},"builtins.float","builtins.object","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_array_almost_equal","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"assert_array_almost_equal_nulp":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["x","y","nulp"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils.assert_array_almost_equal_nulp","name":"assert_array_almost_equal_nulp","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["x","y","nulp"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_array_almost_equal_nulp","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"assert_array_compare":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,1,1,1,1,5,5],"arg_names":["comparison","x","y","err_msg","verbose","header","precision","equal_nan","equal_inf","strict","names"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils.assert_array_compare","name":"assert_array_compare","original_first_arg":"comparison","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,1,1,1,1,5,5],"arg_names":["comparison","x","y","err_msg","verbose","header","precision","equal_nan","equal_inf","strict","names"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.object","builtins.bool","builtins.str","typing.SupportsIndex","builtins.bool","builtins.bool","builtins.bool",{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_array_compare","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"assert_array_equal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,5],"arg_names":["actual","desired","err_msg","verbose","strict"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils.assert_array_equal","name":"assert_array_equal","original_first_arg":"actual","type":{".class":"CallableType","arg_kinds":[0,0,1,1,5],"arg_names":["actual","desired","err_msg","verbose","strict"],"arg_types":["builtins.object","builtins.object","builtins.object","builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_array_equal","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"assert_array_less":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils.assert_array_less","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,5],"arg_names":["x","y","err_msg","verbose","strict"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.testing._private.utils.assert_array_less","name":"assert_array_less","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,1,1,5],"arg_names":["x","y","err_msg","verbose","strict"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.object","builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_array_less","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.testing._private.utils.assert_array_less","name":"assert_array_less","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,5],"arg_names":["x","y","err_msg","verbose","strict"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.object","builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_array_less","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,5],"arg_names":["x","y","err_msg","verbose","strict"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.testing._private.utils.assert_array_less","name":"assert_array_less","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,1,1,5],"arg_names":["x","y","err_msg","verbose","strict"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.object","builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_array_less","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.testing._private.utils.assert_array_less","name":"assert_array_less","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,5],"arg_names":["x","y","err_msg","verbose","strict"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.object","builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_array_less","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,5],"arg_names":["x","y","err_msg","verbose","strict"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.testing._private.utils.assert_array_less","name":"assert_array_less","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0,1,1,5],"arg_names":["x","y","err_msg","verbose","strict"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},"builtins.object","builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_array_less","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.testing._private.utils.assert_array_less","name":"assert_array_less","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1,5],"arg_names":["x","y","err_msg","verbose","strict"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},"builtins.object","builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_array_less","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1,1,5],"arg_names":["x","y","err_msg","verbose","strict"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.object","builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_array_less","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,5],"arg_names":["x","y","err_msg","verbose","strict"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.object","builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_array_less","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1,1,5],"arg_names":["x","y","err_msg","verbose","strict"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},"builtins.object","builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_array_less","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"assert_array_max_ulp":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["a","b","maxulp","dtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils.assert_array_max_ulp","name":"assert_array_max_ulp","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["a","b","maxulp","dtype"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"builtins.float",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy._typing._dtype_like.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_array_max_ulp","ret_type":{".class":"AnyType","missing_import_name":"numpy._typing._array_like.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"assert_equal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,5],"arg_names":["actual","desired","err_msg","verbose","strict"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils.assert_equal","name":"assert_equal","original_first_arg":"actual","type":{".class":"CallableType","arg_kinds":[0,0,1,1,5],"arg_names":["actual","desired","err_msg","verbose","strict"],"arg_types":["builtins.object","builtins.object","builtins.object","builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_equal","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"assert_no_gc_cycles":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils.assert_no_gc_cycles","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.testing._private.utils.assert_no_gc_cycles","name":"assert_no_gc_cycles","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_no_gc_cycles","ret_type":{".class":"Instance","args":[{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.testing._private.utils.assert_no_gc_cycles","name":"assert_no_gc_cycles","setter_type":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_no_gc_cycles","ret_type":{".class":"Instance","args":[{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.testing._private.utils.assert_no_gc_cycles","name":"assert_no_gc_cycles","original_first_arg":"func","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_no_gc_cycles","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.testing._private.utils.assert_no_gc_cycles","name":"assert_no_gc_cycles","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_no_gc_cycles","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_no_gc_cycles","ret_type":{".class":"Instance","args":[{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_no_gc_cycles","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"assert_no_warnings":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils.assert_no_warnings","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.testing._private.utils.assert_no_warnings","name":"assert_no_warnings","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_no_warnings","ret_type":{".class":"Instance","args":[{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.testing._private.utils.assert_no_warnings","name":"assert_no_warnings","setter_type":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_no_warnings","ret_type":{".class":"Instance","args":[{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.testing._private.utils.assert_no_warnings","name":"assert_no_warnings","original_first_arg":"func","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_no_warnings","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.testing._private.utils._T","id":-1,"name":"_T","namespace":"numpy.testing._private.utils.assert_no_warnings","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.testing._private.utils._T","id":-1,"name":"_T","namespace":"numpy.testing._private.utils.assert_no_warnings","upper_bound":"builtins.object","values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.testing._private.utils.assert_no_warnings","name":"assert_no_warnings","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_no_warnings","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.testing._private.utils._T","id":-1,"name":"_T","namespace":"numpy.testing._private.utils.assert_no_warnings","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.testing._private.utils._T","id":-1,"name":"_T","namespace":"numpy.testing._private.utils.assert_no_warnings","upper_bound":"builtins.object","values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_no_warnings","ret_type":{".class":"Instance","args":[{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_no_warnings","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.testing._private.utils._T","id":-1,"name":"_T","namespace":"numpy.testing._private.utils.assert_no_warnings","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.testing._private.utils._T","id":-1,"name":"_T","namespace":"numpy.testing._private.utils.assert_no_warnings","upper_bound":"builtins.object","values":[],"variance":0}]}]}}},"assert_raises":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils.assert_raises","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5],"arg_names":[null,"msg"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.testing._private.utils.assert_raises","name":"assert_raises","original_first_arg":"exception_class","type":{".class":"CallableType","arg_kinds":[0,5],"arg_names":[null,"msg"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_raises","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":"builtins.BaseException","fullname":"numpy.testing._private.utils._ET","id":-1,"name":"_ET","namespace":"numpy.testing._private.utils.assert_raises#0","upper_bound":"builtins.BaseException","values":[],"variance":0}],"extra_attrs":null,"type_ref":"unittest.case._AssertRaisesContext"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":"builtins.BaseException","fullname":"numpy.testing._private.utils._ET","id":-1,"name":"_ET","namespace":"numpy.testing._private.utils.assert_raises#0","upper_bound":"builtins.BaseException","values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.testing._private.utils.assert_raises","name":"assert_raises","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5],"arg_names":[null,"msg"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_raises","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":"builtins.BaseException","fullname":"numpy.testing._private.utils._ET","id":-1,"name":"_ET","namespace":"numpy.testing._private.utils.assert_raises#0","upper_bound":"builtins.BaseException","values":[],"variance":0}],"extra_attrs":null,"type_ref":"unittest.case._AssertRaisesContext"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":"builtins.BaseException","fullname":"numpy.testing._private.utils._ET","id":-1,"name":"_ET","namespace":"numpy.testing._private.utils.assert_raises#0","upper_bound":"builtins.BaseException","values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,2,4],"arg_names":[null,null,"args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.testing._private.utils.assert_raises","name":"assert_raises","original_first_arg":"exception_class","type":{".class":"CallableType","arg_kinds":[0,0,2,4],"arg_names":[null,null,"args","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_raises","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.testing._private.utils.assert_raises","name":"assert_raises","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,2,4],"arg_names":[null,null,"args","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_raises","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,5],"arg_names":[null,"msg"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_raises","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":"builtins.BaseException","fullname":"numpy.testing._private.utils._ET","id":-1,"name":"_ET","namespace":"numpy.testing._private.utils.assert_raises#0","upper_bound":"builtins.BaseException","values":[],"variance":0}],"extra_attrs":null,"type_ref":"unittest.case._AssertRaisesContext"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":"builtins.BaseException","fullname":"numpy.testing._private.utils._ET","id":-1,"name":"_ET","namespace":"numpy.testing._private.utils.assert_raises#0","upper_bound":"builtins.BaseException","values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,2,4],"arg_names":[null,null,"args","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_raises","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"assert_raises_regex":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils.assert_raises_regex","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5],"arg_names":["exception_class","expected_regexp","msg"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.testing._private.utils.assert_raises_regex","name":"assert_raises_regex","original_first_arg":"exception_class","type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["exception_class","expected_regexp","msg"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_raises_regex","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":"builtins.BaseException","fullname":"numpy.testing._private.utils._ET","id":-1,"name":"_ET","namespace":"numpy.testing._private.utils.assert_raises_regex#0","upper_bound":"builtins.BaseException","values":[],"variance":0}],"extra_attrs":null,"type_ref":"unittest.case._AssertRaisesContext"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":"builtins.BaseException","fullname":"numpy.testing._private.utils._ET","id":-1,"name":"_ET","namespace":"numpy.testing._private.utils.assert_raises_regex#0","upper_bound":"builtins.BaseException","values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.testing._private.utils.assert_raises_regex","name":"assert_raises_regex","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["exception_class","expected_regexp","msg"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_raises_regex","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":"builtins.BaseException","fullname":"numpy.testing._private.utils._ET","id":-1,"name":"_ET","namespace":"numpy.testing._private.utils.assert_raises_regex#0","upper_bound":"builtins.BaseException","values":[],"variance":0}],"extra_attrs":null,"type_ref":"unittest.case._AssertRaisesContext"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":"builtins.BaseException","fullname":"numpy.testing._private.utils._ET","id":-1,"name":"_ET","namespace":"numpy.testing._private.utils.assert_raises_regex#0","upper_bound":"builtins.BaseException","values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,2,4],"arg_names":["exception_class","expected_regexp","callable","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.testing._private.utils.assert_raises_regex","name":"assert_raises_regex","original_first_arg":"exception_class","type":{".class":"CallableType","arg_kinds":[0,0,0,2,4],"arg_names":["exception_class","expected_regexp","callable","args","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_raises_regex","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.testing._private.utils.assert_raises_regex","name":"assert_raises_regex","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,2,4],"arg_names":["exception_class","expected_regexp","callable","args","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_raises_regex","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["exception_class","expected_regexp","msg"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_raises_regex","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":"builtins.BaseException","fullname":"numpy.testing._private.utils._ET","id":-1,"name":"_ET","namespace":"numpy.testing._private.utils.assert_raises_regex#0","upper_bound":"builtins.BaseException","values":[],"variance":0}],"extra_attrs":null,"type_ref":"unittest.case._AssertRaisesContext"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":"builtins.BaseException","fullname":"numpy.testing._private.utils._ET","id":-1,"name":"_ET","namespace":"numpy.testing._private.utils.assert_raises_regex#0","upper_bound":"builtins.BaseException","values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,0,2,4],"arg_names":["exception_class","expected_regexp","callable","args","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_raises_regex","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"assert_string_equal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["actual","desired"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils.assert_string_equal","name":"assert_string_equal","original_first_arg":"actual","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["actual","desired"],"arg_types":["builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_string_equal","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"assert_warns":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils.assert_warns","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["warning_class"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.testing._private.utils.assert_warns","name":"assert_warns","original_first_arg":"warning_class","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["warning_class"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_warns","ret_type":{".class":"Instance","args":[{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.testing._private.utils.assert_warns","name":"assert_warns","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["warning_class"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_warns","ret_type":{".class":"Instance","args":[{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,2,4],"arg_names":["warning_class","func","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.testing._private.utils.assert_warns","name":"assert_warns","original_first_arg":"warning_class","type":{".class":"CallableType","arg_kinds":[0,0,2,4],"arg_names":["warning_class","func","args","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_warns","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.testing._private.utils._T","id":-1,"name":"_T","namespace":"numpy.testing._private.utils.assert_warns","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.testing._private.utils._T","id":-1,"name":"_T","namespace":"numpy.testing._private.utils.assert_warns","upper_bound":"builtins.object","values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.testing._private.utils.assert_warns","name":"assert_warns","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,2,4],"arg_names":["warning_class","func","args","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_warns","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.testing._private.utils._T","id":-1,"name":"_T","namespace":"numpy.testing._private.utils.assert_warns","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.testing._private.utils._T","id":-1,"name":"_T","namespace":"numpy.testing._private.utils.assert_warns","upper_bound":"builtins.object","values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["warning_class"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_warns","ret_type":{".class":"Instance","args":[{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,2,4],"arg_names":["warning_class","func","args","kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_warns","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.testing._private.utils._T","id":-1,"name":"_T","namespace":"numpy.testing._private.utils.assert_warns","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.testing._private.utils._T","id":-1,"name":"_T","namespace":"numpy.testing._private.utils.assert_warns","upper_bound":"builtins.object","values":[],"variance":0}]}]}}},"ast":{".class":"SymbolTableNode","cross_ref":"ast","kind":"Gdef","module_hidden":true,"module_public":false},"break_cycles":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils.break_cycles","name":"break_cycles","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"break_cycles","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"build_err_msg":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1],"arg_names":["arrays","err_msg","header","verbose","names","precision"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils.build_err_msg","name":"build_err_msg","original_first_arg":"arrays","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["arrays","err_msg","header","verbose","names","precision"],"arg_types":[{".class":"Instance","args":["builtins.object"],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.object","builtins.str","builtins.bool",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"UnionType","items":["typing.SupportsIndex",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"build_err_msg","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"check_support_sve":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils.check_support_sve","name":"check_support_sve","original_first_arg":"__cache","type":{".class":"CallableType","arg_kinds":[1],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":"builtins.bool","fullname":"numpy.testing._private.utils._T_or_bool","id":-1,"name":"_T_or_bool","namespace":"numpy.testing._private.utils.check_support_sve","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"check_support_sve","ret_type":{".class":"TypeVarType","default":"builtins.bool","fullname":"numpy.testing._private.utils._T_or_bool","id":-1,"name":"_T_or_bool","namespace":"numpy.testing._private.utils.check_support_sve","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":"builtins.bool","fullname":"numpy.testing._private.utils._T_or_bool","id":-1,"name":"_T_or_bool","namespace":"numpy.testing._private.utils.check_support_sve","upper_bound":"builtins.object","values":[],"variance":0}]}}},"clear_and_catch_warnings":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.testing._private.utils._W_co","id":1,"name":"_W_co","namespace":"numpy.testing._private.utils.clear_and_catch_warnings","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"warnings.catch_warnings"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.testing._private.utils.clear_and_catch_warnings","name":"clear_and_catch_warnings","type_vars":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.testing._private.utils._W_co","id":1,"name":"_W_co","namespace":"numpy.testing._private.utils.clear_and_catch_warnings","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils.clear_and_catch_warnings","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.testing._private.utils","mro":["numpy.testing._private.utils.clear_and_catch_warnings","warnings.catch_warnings","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils.clear_and_catch_warnings.__init__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":[null,"record","modules"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.testing._private.utils.clear_and_catch_warnings.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":[null,"record","modules"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.testing._private.utils.clear_and_catch_warnings"},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of clear_and_catch_warnings","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.testing._private.utils.clear_and_catch_warnings.__init__","name":"__init__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":[null,"record","modules"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.testing._private.utils.clear_and_catch_warnings"},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of clear_and_catch_warnings","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":[null,"record","modules"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.testing._private.utils.clear_and_catch_warnings.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":[null,"record","modules"],"arg_types":[{".class":"Instance","args":[{".class":"NoneType"}],"extra_attrs":null,"type_ref":"numpy.testing._private.utils.clear_and_catch_warnings"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of clear_and_catch_warnings","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.testing._private.utils.clear_and_catch_warnings.__init__","name":"__init__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":[null,"record","modules"],"arg_types":[{".class":"Instance","args":[{".class":"NoneType"}],"extra_attrs":null,"type_ref":"numpy.testing._private.utils.clear_and_catch_warnings"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of clear_and_catch_warnings","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":[null,"record","modules"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"numpy.testing._private.utils.clear_and_catch_warnings.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":[null,"record","modules"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.testing._private.utils._W_co","id":1,"name":"_W_co","namespace":"numpy.testing._private.utils.clear_and_catch_warnings","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.testing._private.utils.clear_and_catch_warnings"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of clear_and_catch_warnings","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.testing._private.utils.clear_and_catch_warnings.__init__","name":"__init__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":[null,"record","modules"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.testing._private.utils._W_co","id":1,"name":"_W_co","namespace":"numpy.testing._private.utils.clear_and_catch_warnings","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.testing._private.utils.clear_and_catch_warnings"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of clear_and_catch_warnings","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":[null,"record","modules"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3}],"extra_attrs":null,"type_ref":"numpy.testing._private.utils.clear_and_catch_warnings"},{".class":"LiteralType","fallback":"builtins.bool","value":true},{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of clear_and_catch_warnings","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":[null,"record","modules"],"arg_types":[{".class":"Instance","args":[{".class":"NoneType"}],"extra_attrs":null,"type_ref":"numpy.testing._private.utils.clear_and_catch_warnings"},{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of clear_and_catch_warnings","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":[null,"record","modules"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.testing._private.utils._W_co","id":1,"name":"_W_co","namespace":"numpy.testing._private.utils.clear_and_catch_warnings","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.testing._private.utils.clear_and_catch_warnings"},"builtins.bool",{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of clear_and_catch_warnings","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"class_modules":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready","has_explicit_value"],"fullname":"numpy.testing._private.utils.clear_and_catch_warnings.class_modules","name":"class_modules","setter_type":null,"type":{".class":"Instance","args":["types.ModuleType"],"extra_attrs":null,"type_ref":"builtins.tuple"}}},"modules":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","final_unset_in_class","is_ready"],"fullname":"numpy.testing._private.utils.clear_and_catch_warnings.modules","name":"modules","setter_type":null,"type":{".class":"Instance","args":["types.ModuleType"],"extra_attrs":null,"type_ref":"builtins.set"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.testing._private.utils.clear_and_catch_warnings.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"fullname":"numpy.testing._private.utils._W_co","id":1,"name":"_W_co","namespace":"numpy.testing._private.utils.clear_and_catch_warnings","upper_bound":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"values":[],"variance":1}],"extra_attrs":null,"type_ref":"numpy.testing._private.utils.clear_and_catch_warnings"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_W_co"],"typeddict_type":null}},"decorate_methods":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["cls","decorator","testmatch"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils.decorate_methods","name":"decorate_methods","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["cls","decorator","testmatch"],"arg_types":["builtins.type",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"decorate_methods","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"jiffies":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1,1],"arg_names":["_proc_pid_stat","_load_time"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils.jiffies","name":"jiffies","original_first_arg":"_proc_pid_stat","type":{".class":"CallableType","arg_kinds":[1,1],"arg_names":["_proc_pid_stat","_load_time"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.StrOrBytesPath"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.float"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"jiffies","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"measure":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["code_str","times","label"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils.measure","name":"measure","original_first_arg":"code_str","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["code_str","times","label"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},"ast.AST"],"uses_pep604_syntax":true},"builtins.int",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"measure","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"memusage":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1],"arg_names":["_proc_pid_stat"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils.memusage","name":"memusage","original_first_arg":"_proc_pid_stat","type":{".class":"CallableType","arg_kinds":[1],"arg_names":["_proc_pid_stat"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.StrOrBytesPath"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"memusage","ret_type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_hidden":true,"module_public":false},"print_assert_equal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["test_string","actual","desired"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils.print_assert_equal","name":"print_assert_equal","original_first_arg":"test_string","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["test_string","actual","desired"],"arg_types":["builtins.str","builtins.object","builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"print_assert_equal","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"run_threaded":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils.run_threaded","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1],"arg_names":["func","max_workers","pass_count","pass_barrier","outer_iterations","prepare_args"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.testing._private.utils.run_threaded","name":"run_threaded","original_first_arg":"func","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1],"arg_names":["func","max_workers","pass_count","pass_barrier","outer_iterations","prepare_args"],"arg_types":[{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"builtins.int","builtins.bool","builtins.bool","builtins.int",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"run_threaded","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.testing._private.utils.run_threaded","name":"run_threaded","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1],"arg_names":["func","max_workers","pass_count","pass_barrier","outer_iterations","prepare_args"],"arg_types":[{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"builtins.int","builtins.bool","builtins.bool","builtins.int",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"run_threaded","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0,0],"arg_names":["func","max_workers","pass_count","pass_barrier","outer_iterations","prepare_args"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.testing._private.utils.run_threaded","name":"run_threaded","original_first_arg":"func","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0],"arg_names":["func","max_workers","pass_count","pass_barrier","outer_iterations","prepare_args"],"arg_types":[{".class":"CallableType","arg_kinds":[2],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"builtins.int","builtins.bool","builtins.bool","builtins.int",{".class":"TupleType","implicit":false,"items":[{".class":"UnpackType","type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"run_threaded","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.testing._private.utils.run_threaded","name":"run_threaded","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0],"arg_names":["func","max_workers","pass_count","pass_barrier","outer_iterations","prepare_args"],"arg_types":[{".class":"CallableType","arg_kinds":[2],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"builtins.int","builtins.bool","builtins.bool","builtins.int",{".class":"TupleType","implicit":false,"items":[{".class":"UnpackType","type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"run_threaded","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,3],"arg_names":["func","max_workers","pass_count","pass_barrier","outer_iterations","prepare_args"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.testing._private.utils.run_threaded","name":"run_threaded","original_first_arg":"func","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,3],"arg_names":["func","max_workers","pass_count","pass_barrier","outer_iterations","prepare_args"],"arg_types":[{".class":"CallableType","arg_kinds":[2],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"builtins.int","builtins.bool","builtins.bool","builtins.int",{".class":"TupleType","implicit":false,"items":[{".class":"UnpackType","type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"run_threaded","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.testing._private.utils.run_threaded","name":"run_threaded","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,3],"arg_names":["func","max_workers","pass_count","pass_barrier","outer_iterations","prepare_args"],"arg_types":[{".class":"CallableType","arg_kinds":[2],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"builtins.int","builtins.bool","builtins.bool","builtins.int",{".class":"TupleType","implicit":false,"items":[{".class":"UnpackType","type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"run_threaded","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1,1],"arg_names":["func","max_workers","pass_count","pass_barrier","outer_iterations","prepare_args"],"arg_types":[{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"builtins.int","builtins.bool","builtins.bool","builtins.int",{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"run_threaded","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0,0,0],"arg_names":["func","max_workers","pass_count","pass_barrier","outer_iterations","prepare_args"],"arg_types":[{".class":"CallableType","arg_kinds":[2],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"builtins.int","builtins.bool","builtins.bool","builtins.int",{".class":"TupleType","implicit":false,"items":[{".class":"UnpackType","type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"run_threaded","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,3],"arg_names":["func","max_workers","pass_count","pass_barrier","outer_iterations","prepare_args"],"arg_types":[{".class":"CallableType","arg_kinds":[2],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"builtins.int","builtins.bool","builtins.bool","builtins.int",{".class":"TupleType","implicit":false,"items":[{".class":"UnpackType","type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"run_threaded","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"rundocs":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1,1],"arg_names":["filename","raise_on_error"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils.rundocs","name":"rundocs","original_first_arg":"filename","type":{".class":"CallableType","arg_kinds":[1,1],"arg_names":["filename","raise_on_error"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.StrPath"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rundocs","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"runstring":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["astr","dict"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils.runstring","name":"runstring","original_first_arg":"astr","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["astr","dict"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},"types.CodeType"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"runstring","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"suppress_warnings":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"numpy.testing._private.utils.suppress_warnings","name":"suppress_warnings","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils.suppress_warnings","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"numpy.testing._private.utils","mro":["numpy.testing._private.utils.suppress_warnings","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"func"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.testing._private.utils.suppress_warnings.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"func"],"arg_types":["numpy.testing._private.utils.suppress_warnings",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.testing._private.utils._FT","id":-1,"name":"_FT","namespace":"numpy.testing._private.utils.suppress_warnings.__call__","upper_bound":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of suppress_warnings","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.testing._private.utils._FT","id":-1,"name":"_FT","namespace":"numpy.testing._private.utils.suppress_warnings.__call__","upper_bound":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.testing._private.utils._FT","id":-1,"name":"_FT","namespace":"numpy.testing._private.utils.suppress_warnings.__call__","upper_bound":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"values":[],"variance":0}]}}},"__enter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.testing._private.utils.suppress_warnings.__enter__","name":"__enter__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["numpy.testing._private.utils.suppress_warnings"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__enter__ of suppress_warnings","ret_type":{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.Self","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__exit__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":[null,null,null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.testing._private.utils.suppress_warnings.__exit__","name":"__exit__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":[null,null,null,null],"arg_types":["numpy.testing._private.utils.suppress_warnings",{".class":"UnionType","items":[{".class":"TypeType","item":"builtins.BaseException"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.BaseException",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["types.TracebackType",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__exit__ of suppress_warnings","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":[null,"forwarding_rule"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.testing._private.utils.suppress_warnings.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":[null,"forwarding_rule"],"arg_types":["numpy.testing._private.utils.suppress_warnings",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"always"},{".class":"LiteralType","fallback":"builtins.str","value":"module"},{".class":"LiteralType","fallback":"builtins.str","value":"once"},{".class":"LiteralType","fallback":"builtins.str","value":"location"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of suppress_warnings","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"filter":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":[null,"category","message","module"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.testing._private.utils.suppress_warnings.filter","name":"filter","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":[null,"category","message","module"],"arg_types":["numpy.testing._private.utils.suppress_warnings",{".class":"TypeType","item":"builtins.Warning"},"builtins.str",{".class":"UnionType","items":["types.ModuleType",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"filter of suppress_warnings","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"log":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","final_unset_in_class","is_ready"],"fullname":"numpy.testing._private.utils.suppress_warnings.log","name":"log","setter_type":null,"type":{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3}}},"record":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":[null,"category","message","module"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"numpy.testing._private.utils.suppress_warnings.record","name":"record","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":[null,"category","message","module"],"arg_types":["numpy.testing._private.utils.suppress_warnings",{".class":"TypeType","item":"builtins.Warning"},"builtins.str",{".class":"UnionType","items":["types.ModuleType",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"record of suppress_warnings","ret_type":{".class":"AnyType","missing_import_name":"numpy.testing._private.utils.TypeAlias","source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"numpy.testing._private.utils.suppress_warnings.Self","id":0,"name":"Self","namespace":"","upper_bound":"numpy.testing._private.utils.suppress_warnings","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"sys":{".class":"SymbolTableNode","cross_ref":"sys","kind":"Gdef","module_hidden":true,"module_public":false},"tempdir":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils.tempdir","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1,1,1],"arg_names":["suffix","prefix","dir"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.testing._private.utils.tempdir","name":"tempdir","original_first_arg":"suffix","type":{".class":"CallableType","arg_kinds":[1,1,1],"arg_names":["suffix","prefix","dir"],"arg_types":[{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tempdir","ret_type":{".class":"Instance","args":["builtins.str",{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.testing._private.utils.tempdir","name":"tempdir","setter_type":null,"type":{".class":"CallableType","arg_kinds":[1,1,1],"arg_names":["suffix","prefix","dir"],"arg_types":[{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tempdir","ret_type":{".class":"Instance","args":["builtins.str",{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1,1,3],"arg_names":["suffix","prefix","dir"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.testing._private.utils.tempdir","name":"tempdir","original_first_arg":"suffix","type":{".class":"CallableType","arg_kinds":[1,1,3],"arg_names":["suffix","prefix","dir"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir#1","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir#1","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir#1","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}],"type_ref":"_typeshed.GenericPath"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tempdir","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir#1","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir#1","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.testing._private.utils.tempdir","name":"tempdir","setter_type":null,"type":{".class":"CallableType","arg_kinds":[1,1,3],"arg_names":["suffix","prefix","dir"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir#1","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir#1","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir#1","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}],"type_ref":"_typeshed.GenericPath"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tempdir","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir#1","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir#1","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1,3,5],"arg_names":["suffix","prefix","dir"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.testing._private.utils.tempdir","name":"tempdir","original_first_arg":"suffix","type":{".class":"CallableType","arg_kinds":[1,3,5],"arg_names":["suffix","prefix","dir"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir#2","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir#2","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir#2","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}],"type_ref":"_typeshed.GenericPath"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tempdir","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir#2","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir#2","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.testing._private.utils.tempdir","name":"tempdir","setter_type":null,"type":{".class":"CallableType","arg_kinds":[1,3,5],"arg_names":["suffix","prefix","dir"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir#2","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir#2","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir#2","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}],"type_ref":"_typeshed.GenericPath"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tempdir","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir#2","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir#2","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["suffix","prefix","dir"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.testing._private.utils.tempdir","name":"tempdir","original_first_arg":"suffix","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["suffix","prefix","dir"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}],"type_ref":"_typeshed.GenericPath"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tempdir","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.testing._private.utils.tempdir","name":"tempdir","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["suffix","prefix","dir"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}],"type_ref":"_typeshed.GenericPath"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tempdir","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[1,1,1],"arg_names":["suffix","prefix","dir"],"arg_types":[{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tempdir","ret_type":{".class":"Instance","args":["builtins.str",{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[1,1,3],"arg_names":["suffix","prefix","dir"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir#1","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir#1","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir#1","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}],"type_ref":"_typeshed.GenericPath"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tempdir","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir#1","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir#1","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}]},{".class":"CallableType","arg_kinds":[1,3,5],"arg_names":["suffix","prefix","dir"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir#2","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir#2","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir#2","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}],"type_ref":"_typeshed.GenericPath"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tempdir","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir#2","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir#2","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["suffix","prefix","dir"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}],"type_ref":"_typeshed.GenericPath"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tempdir","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.tempdir","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}]}]}}},"temppath":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"numpy.testing._private.utils.temppath","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1,1,1,1],"arg_names":["suffix","prefix","dir","text"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.testing._private.utils.temppath","name":"temppath","original_first_arg":"suffix","type":{".class":"CallableType","arg_kinds":[1,1,1,1],"arg_names":["suffix","prefix","dir","text"],"arg_types":[{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"temppath","ret_type":{".class":"Instance","args":["builtins.str",{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.testing._private.utils.temppath","name":"temppath","setter_type":null,"type":{".class":"CallableType","arg_kinds":[1,1,1,1],"arg_names":["suffix","prefix","dir","text"],"arg_types":[{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"temppath","ret_type":{".class":"Instance","args":["builtins.str",{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["suffix","prefix","dir","text"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.testing._private.utils.temppath","name":"temppath","original_first_arg":"suffix","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["suffix","prefix","dir","text"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#1","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#1","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#1","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}],"type_ref":"_typeshed.GenericPath"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"temppath","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#1","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#1","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.testing._private.utils.temppath","name":"temppath","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["suffix","prefix","dir","text"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#1","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#1","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#1","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}],"type_ref":"_typeshed.GenericPath"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"temppath","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#1","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#1","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1,1,3,5],"arg_names":["suffix","prefix","dir","text"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.testing._private.utils.temppath","name":"temppath","original_first_arg":"suffix","type":{".class":"CallableType","arg_kinds":[1,1,3,5],"arg_names":["suffix","prefix","dir","text"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#2","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#2","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#2","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}],"type_ref":"_typeshed.GenericPath"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"temppath","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#2","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#2","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.testing._private.utils.temppath","name":"temppath","setter_type":null,"type":{".class":"CallableType","arg_kinds":[1,1,3,5],"arg_names":["suffix","prefix","dir","text"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#2","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#2","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#2","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}],"type_ref":"_typeshed.GenericPath"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"temppath","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#2","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#2","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["suffix","prefix","dir","text"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.testing._private.utils.temppath","name":"temppath","original_first_arg":"suffix","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["suffix","prefix","dir","text"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#3","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#3","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#3","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}],"type_ref":"_typeshed.GenericPath"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"temppath","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#3","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#3","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.testing._private.utils.temppath","name":"temppath","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["suffix","prefix","dir","text"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#3","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#3","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#3","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}],"type_ref":"_typeshed.GenericPath"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"temppath","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#3","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#3","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1,3,5,5],"arg_names":["suffix","prefix","dir","text"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.testing._private.utils.temppath","name":"temppath","original_first_arg":"suffix","type":{".class":"CallableType","arg_kinds":[1,3,5,5],"arg_names":["suffix","prefix","dir","text"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#4","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#4","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#4","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}],"type_ref":"_typeshed.GenericPath"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"temppath","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#4","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#4","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.testing._private.utils.temppath","name":"temppath","setter_type":null,"type":{".class":"CallableType","arg_kinds":[1,3,5,5],"arg_names":["suffix","prefix","dir","text"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#4","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#4","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#4","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}],"type_ref":"_typeshed.GenericPath"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"temppath","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#4","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#4","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["suffix","prefix","dir","text"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"numpy.testing._private.utils.temppath","name":"temppath","original_first_arg":"suffix","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["suffix","prefix","dir","text"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}],"type_ref":"_typeshed.GenericPath"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"temppath","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"numpy.testing._private.utils.temppath","name":"temppath","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["suffix","prefix","dir","text"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}],"type_ref":"_typeshed.GenericPath"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"temppath","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[1,1,1,1],"arg_names":["suffix","prefix","dir","text"],"arg_types":[{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"temppath","ret_type":{".class":"Instance","args":["builtins.str",{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["suffix","prefix","dir","text"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#1","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#1","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#1","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}],"type_ref":"_typeshed.GenericPath"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"temppath","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#1","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#1","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}]},{".class":"CallableType","arg_kinds":[1,1,3,5],"arg_names":["suffix","prefix","dir","text"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#2","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#2","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#2","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}],"type_ref":"_typeshed.GenericPath"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"temppath","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#2","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#2","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}]},{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["suffix","prefix","dir","text"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#3","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#3","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#3","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}],"type_ref":"_typeshed.GenericPath"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"temppath","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#3","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#3","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}]},{".class":"CallableType","arg_kinds":[1,3,5,5],"arg_names":["suffix","prefix","dir","text"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#4","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#4","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#4","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}],"type_ref":"_typeshed.GenericPath"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"temppath","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#4","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath#4","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}]},{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["suffix","prefix","dir","text"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}],"type_ref":"_typeshed.GenericPath"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"temppath","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"AnyStr","namespace":"numpy.testing._private.utils.temppath","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}]}]}}},"type_check_only":{".class":"SymbolTableNode","cross_ref":"typing.type_check_only","kind":"Gdef","module_hidden":true,"module_public":false},"types":{".class":"SymbolTableNode","cross_ref":"types","kind":"Gdef","module_hidden":true,"module_public":false},"unittest":{".class":"SymbolTableNode","cross_ref":"unittest","kind":"Gdef","module_hidden":true,"module_public":false},"verbose":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"numpy.testing._private.utils.verbose","name":"verbose","setter_type":null,"type":"builtins.int"}},"warnings":{".class":"SymbolTableNode","cross_ref":"warnings","kind":"Gdef","module_hidden":true,"module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/testing/_private/utils.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/testing/_private/utils.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/testing/_private/utils.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..9b5b93da48e6869669fd4fd5d61c559a899cba9f --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/testing/_private/utils.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[6,26,32,1,2,3,4,5,7,8,9,10,28,29,31,1,1,1,1,1,1],"dep_prios":[5,5,5,10,10,10,10,10,5,5,5,5,5,5,10,5,30,30,30,30,30],"dependencies":["collections.abc","unittest.case","numpy._typing","ast","sys","types","unittest","warnings","contextlib","pathlib","re","typing","_typeshed","typing_extensions","numpy","builtins","_frozen_importlib","abc","numpy._typing._array_like","numpy._typing._nbit_base","os"],"hash":"6164b516fdcb3e873af9de7fa462025c49baf81c","id":"numpy.testing._private.utils","ignore_all":true,"interface_hash":"01c722ab4945a482e91e081f088ea789d0edf365","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/testing/_private/utils.pyi","plugin_data":null,"size":12960,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/testing/overrides.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/testing/overrides.data.json new file mode 100644 index 0000000000000000000000000000000000000000..32a23f079a9c0a06538b1091ceeaac7fe13fa4ea --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/testing/overrides.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.testing.overrides","future_import_flags":[],"is_partial_stub_package":false,"is_stub":true,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_hidden":true,"module_public":false},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef","module_hidden":true,"module_public":false},"Hashable":{".class":"SymbolTableNode","cross_ref":"typing.Hashable","kind":"Gdef","module_hidden":true,"module_public":false},"TypeIs":{".class":"SymbolTableNode","cross_ref":"typing_extensions.TypeIs","kind":"Gdef","module_hidden":true,"module_public":false},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.testing.overrides.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.testing.overrides.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.testing.overrides.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.testing.overrides.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.testing.overrides.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.testing.overrides.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"allows_array_function_override":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["func"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.testing.overrides.allows_array_function_override","name":"allows_array_function_override","original_first_arg":"func","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["func"],"arg_types":["typing.Hashable"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"allows_array_function_override","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"allows_array_ufunc_override":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["func"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.testing.overrides.allows_array_ufunc_override","name":"allows_array_ufunc_override","original_first_arg":"func","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["func"],"arg_types":["builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"allows_array_ufunc_override","ret_type":"builtins.bool","type_guard":null,"type_is":"numpy.ufunc","unpack_kwargs":false,"variables":[]}}},"get_overridable_numpy_array_functions":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.testing.overrides.get_overridable_numpy_array_functions","name":"get_overridable_numpy_array_functions","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_overridable_numpy_array_functions","ret_type":{".class":"Instance","args":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"extra_attrs":null,"type_ref":"builtins.set"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_overridable_numpy_ufuncs":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.testing.overrides.get_overridable_numpy_ufuncs","name":"get_overridable_numpy_ufuncs","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_overridable_numpy_ufuncs","ret_type":{".class":"Instance","args":["numpy.ufunc"],"extra_attrs":null,"type_ref":"builtins.set"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"np":{".class":"SymbolTableNode","cross_ref":"numpy","kind":"Gdef","module_hidden":true,"module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/testing/overrides.pyi"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/testing/overrides.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/testing/overrides.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..fe607ce7de323ca029041b0c55cd3716ed8cb28f --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/testing/overrides.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[1,2,4,6,1,1,1],"dep_prios":[5,5,5,10,5,30,30],"dependencies":["collections.abc","typing","typing_extensions","numpy","builtins","_frozen_importlib","abc"],"hash":"8df95a500ce8d3647a76be2e9cd11a1416175783","id":"numpy.testing.overrides","ignore_all":true,"interface_hash":"d2435086f6a38e24334a2f0e641dee1f53ce4787","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/testing/overrides.pyi","plugin_data":null,"size":397,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/typing/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/typing/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..94e58b51d621749467d4a185afa90c42136642cb --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/typing/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"numpy.typing","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","ArrayLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.ArrayLike","kind":"Gdef"},"DTypeLike":{".class":"SymbolTableNode","cross_ref":"numpy._typing._dtype_like.DTypeLike","kind":"Gdef"},"NBitBase":{".class":"SymbolTableNode","cross_ref":"numpy._typing._nbit_base.NBitBase","kind":"Gdef"},"NDArray":{".class":"SymbolTableNode","cross_ref":"numpy._typing._array_like.NDArray","kind":"Gdef"},"PytestTester":{".class":"SymbolTableNode","cross_ref":"numpy._pytesttester.PytestTester","kind":"Gdef","module_public":false},"__DIR":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.typing.__DIR","name":"__DIR","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__DIR_SET":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.typing.__DIR_SET","name":"__DIR_SET","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.frozenset"}}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.typing.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.typing.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__dir__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.typing.__dir__","name":"__dir__","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__dir__","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.typing.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.typing.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__getattr__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"numpy.typing.__getattr__","name":"__getattr__","original_first_arg":"name","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getattr__","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.typing.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.typing.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.typing.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"numpy.typing.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_docstrings":{".class":"SymbolTableNode","cross_ref":"numpy._typing._add_docstring._docstrings","kind":"Gdef","module_public":false},"test":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"numpy.typing.test","name":"test","setter_type":null,"type":"numpy._pytesttester.PytestTester"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/typing/__init__.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/typing/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/typing/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..6712dfd060d5d9fe2b88041b4420e0523ba4baa7 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/numpy/typing/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[193,160,198,1,1,1,1],"dep_prios":[5,5,5,5,30,30,30],"dependencies":["numpy._typing._add_docstring","numpy._typing","numpy._pytesttester","builtins","_frozen_importlib","abc","typing"],"hash":"4b68e052af9969ddf989bbbc0c8afc1d80cf2f3a","id":"numpy.typing","ignore_all":true,"interface_hash":"95f0fb25388d269c122e71c2f69d3bdffe406f88","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/numpy/typing/__init__.py","plugin_data":null,"size":6048,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..9805d933ee74ef4c1a27ed268c6651d5d7295773 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic._internal","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/__init__.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..875b6f1e13c7931430ac89911d4a93e95de32e26 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106713,"dep_lines":[1,1,1,1],"dep_prios":[5,30,30,30],"dependencies":["builtins","_frozen_importlib","abc","typing"],"hash":"da39a3ee5e6b4b0d3255bfef95601890afd80709","id":"pydantic._internal","ignore_all":true,"interface_hash":"8903dba68cfb347992e3f4092471686d01aaa196","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/__init__.py","plugin_data":null,"size":0,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_config.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_config.data.json new file mode 100644 index 0000000000000000000000000000000000000000..1ecf0cc3a80c7f6086b101f41bb38dca8d2e9336 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_config.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic._internal._config","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","AliasGenerator":{".class":"SymbolTableNode","cross_ref":"pydantic.aliases.AliasGenerator","kind":"Gdef"},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"ComputedFieldInfo":{".class":"SymbolTableNode","cross_ref":"pydantic.fields.ComputedFieldInfo","kind":"Gdef"},"ConfigDict":{".class":"SymbolTableNode","cross_ref":"pydantic.config.ConfigDict","kind":"Gdef"},"ConfigWrapper":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._config.ConfigWrapper","name":"ConfigWrapper","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._config.ConfigWrapper","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic._internal._config","mro":["pydantic._internal._config.ConfigWrapper","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5],"arg_names":["self","config","check"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._config.ConfigWrapper.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["self","config","check"],"arg_types":["pydantic._internal._config.ConfigWrapper",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.config.ConfigDict"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of ConfigWrapper","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._config.ConfigWrapper.__repr__","name":"__repr__","original_first_arg":"self","type":null}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic._internal._config.ConfigWrapper.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"alias_generator":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.alias_generator","name":"alias_generator","setter_type":null,"type":{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"pydantic.aliases.AliasGenerator",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"allow_inf_nan":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.allow_inf_nan","name":"allow_inf_nan","setter_type":null,"type":"builtins.bool"}},"arbitrary_types_allowed":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.arbitrary_types_allowed","name":"arbitrary_types_allowed","setter_type":null,"type":"builtins.bool"}},"cache_strings":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.cache_strings","name":"cache_strings","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"LiteralType","fallback":"builtins.str","value":"all"},{".class":"LiteralType","fallback":"builtins.str","value":"keys"},{".class":"LiteralType","fallback":"builtins.str","value":"none"}],"uses_pep604_syntax":true}}},"coerce_numbers_to_str":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.coerce_numbers_to_str","name":"coerce_numbers_to_str","setter_type":null,"type":"builtins.bool"}},"config_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.config_dict","name":"config_dict","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.config.ConfigDict"}}},"core_config":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","title"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._config.ConfigWrapper.core_config","name":"core_config","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","title"],"arg_types":["pydantic._internal._config.ConfigWrapper",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"core_config of ConfigWrapper","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreConfig"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"defer_build":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.defer_build","name":"defer_build","setter_type":null,"type":"builtins.bool"}},"extra":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.extra","name":"extra","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.config.ExtraValues"},{".class":"NoneType"}],"uses_pep604_syntax":true}}},"field_title_generator":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.field_title_generator","name":"field_title_generator","setter_type":null,"type":{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["builtins.str",{".class":"UnionType","items":["pydantic.fields.FieldInfo","pydantic.fields.ComputedFieldInfo"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":true}}},"for_model":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0],"arg_names":["cls","bases","namespace","raw_annotations","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated"],"fullname":"pydantic._internal._config.ConfigWrapper.for_model","name":"for_model","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":["cls","bases","namespace","raw_annotations","kwargs"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._config.ConfigWrapper.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._config.ConfigWrapper","values":[],"variance":0}},{".class":"Instance","args":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"for_model of ConfigWrapper","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._config.ConfigWrapper.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._config.ConfigWrapper","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._config.ConfigWrapper.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._config.ConfigWrapper","values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic._internal._config.ConfigWrapper.for_model","name":"for_model","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":["cls","bases","namespace","raw_annotations","kwargs"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._config.ConfigWrapper.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._config.ConfigWrapper","values":[],"variance":0}},{".class":"Instance","args":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"for_model of ConfigWrapper","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._config.ConfigWrapper.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._config.ConfigWrapper","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._config.ConfigWrapper.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._config.ConfigWrapper","values":[],"variance":0}]}}}},"from_attributes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.from_attributes","name":"from_attributes","setter_type":null,"type":"builtins.bool"}},"frozen":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.frozen","name":"frozen","setter_type":null,"type":"builtins.bool"}},"hide_input_in_errors":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.hide_input_in_errors","name":"hide_input_in_errors","setter_type":null,"type":"builtins.bool"}},"ignored_types":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.ignored_types","name":"ignored_types","setter_type":null,"type":{".class":"Instance","args":["builtins.type"],"extra_attrs":null,"type_ref":"builtins.tuple"}}},"json_encoders":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.json_encoders","name":"json_encoders","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeType","item":"builtins.object"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.config.JsonEncoder"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}}},"json_schema_extra":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.json_schema_extra","name":"json_schema_extra","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.config.JsonDict"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.config.JsonSchemaExtraCallable"},{".class":"NoneType"}],"uses_pep604_syntax":true}}},"json_schema_mode_override":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.json_schema_mode_override","name":"json_schema_mode_override","setter_type":null,"type":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"validation"},{".class":"LiteralType","fallback":"builtins.str","value":"serialization"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"json_schema_serialization_defaults_required":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.json_schema_serialization_defaults_required","name":"json_schema_serialization_defaults_required","setter_type":null,"type":"builtins.bool"}},"loc_by_alias":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.loc_by_alias","name":"loc_by_alias","setter_type":null,"type":"builtins.bool"}},"model_title_generator":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.model_title_generator","name":"model_title_generator","setter_type":null,"type":{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.type"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":true}}},"plugin_settings":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.plugin_settings","name":"plugin_settings","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","builtins.object"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}}},"populate_by_name":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.populate_by_name","name":"populate_by_name","setter_type":null,"type":"builtins.bool"}},"protected_namespaces":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.protected_namespaces","name":"protected_namespaces","setter_type":null,"type":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.tuple"}}},"regex_engine":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.regex_engine","name":"regex_engine","setter_type":null,"type":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"rust-regex"},{".class":"LiteralType","fallback":"builtins.str","value":"python-re"}],"uses_pep604_syntax":false}}},"revalidate_instances":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.revalidate_instances","name":"revalidate_instances","setter_type":null,"type":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"always"},{".class":"LiteralType","fallback":"builtins.str","value":"never"},{".class":"LiteralType","fallback":"builtins.str","value":"subclass-instances"}],"uses_pep604_syntax":false}}},"schema_generator":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.schema_generator","name":"schema_generator","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeType","item":"pydantic._internal._generate_schema.GenerateSchema"},{".class":"NoneType"}],"uses_pep604_syntax":true}}},"ser_json_bytes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.ser_json_bytes","name":"ser_json_bytes","setter_type":null,"type":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"utf8"},{".class":"LiteralType","fallback":"builtins.str","value":"base64"},{".class":"LiteralType","fallback":"builtins.str","value":"hex"}],"uses_pep604_syntax":false}}},"ser_json_inf_nan":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.ser_json_inf_nan","name":"ser_json_inf_nan","setter_type":null,"type":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"null"},{".class":"LiteralType","fallback":"builtins.str","value":"constants"},{".class":"LiteralType","fallback":"builtins.str","value":"strings"}],"uses_pep604_syntax":false}}},"ser_json_temporal":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.ser_json_temporal","name":"ser_json_temporal","setter_type":null,"type":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"iso8601"},{".class":"LiteralType","fallback":"builtins.str","value":"seconds"},{".class":"LiteralType","fallback":"builtins.str","value":"milliseconds"}],"uses_pep604_syntax":false}}},"ser_json_timedelta":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.ser_json_timedelta","name":"ser_json_timedelta","setter_type":null,"type":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"iso8601"},{".class":"LiteralType","fallback":"builtins.str","value":"float"}],"uses_pep604_syntax":false}}},"serialize_by_alias":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.serialize_by_alias","name":"serialize_by_alias","setter_type":null,"type":"builtins.bool"}},"str_max_length":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.str_max_length","name":"str_max_length","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"str_min_length":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.str_min_length","name":"str_min_length","setter_type":null,"type":"builtins.int"}},"str_strip_whitespace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.str_strip_whitespace","name":"str_strip_whitespace","setter_type":null,"type":"builtins.bool"}},"str_to_lower":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.str_to_lower","name":"str_to_lower","setter_type":null,"type":"builtins.bool"}},"str_to_upper":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.str_to_upper","name":"str_to_upper","setter_type":null,"type":"builtins.bool"}},"strict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.strict","name":"strict","setter_type":null,"type":"builtins.bool"}},"title":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.title","name":"title","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"url_preserve_empty_path":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.url_preserve_empty_path","name":"url_preserve_empty_path","setter_type":null,"type":"builtins.bool"}},"use_attribute_docstrings":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.use_attribute_docstrings","name":"use_attribute_docstrings","setter_type":null,"type":"builtins.bool"}},"use_enum_values":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.use_enum_values","name":"use_enum_values","setter_type":null,"type":"builtins.bool"}},"val_json_bytes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.val_json_bytes","name":"val_json_bytes","setter_type":null,"type":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"utf8"},{".class":"LiteralType","fallback":"builtins.str","value":"base64"},{".class":"LiteralType","fallback":"builtins.str","value":"hex"}],"uses_pep604_syntax":false}}},"val_temporal_unit":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.val_temporal_unit","name":"val_temporal_unit","setter_type":null,"type":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"seconds"},{".class":"LiteralType","fallback":"builtins.str","value":"milliseconds"},{".class":"LiteralType","fallback":"builtins.str","value":"infer"}],"uses_pep604_syntax":false}}},"validate_assignment":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.validate_assignment","name":"validate_assignment","setter_type":null,"type":"builtins.bool"}},"validate_by_alias":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.validate_by_alias","name":"validate_by_alias","setter_type":null,"type":"builtins.bool"}},"validate_by_name":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.validate_by_name","name":"validate_by_name","setter_type":null,"type":"builtins.bool"}},"validate_default":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.validate_default","name":"validate_default","setter_type":null,"type":"builtins.bool"}},"validate_return":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.validate_return","name":"validate_return","setter_type":null,"type":"builtins.bool"}},"validation_error_cause":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._config.ConfigWrapper.validation_error_cause","name":"validation_error_cause","setter_type":null,"type":"builtins.bool"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._config.ConfigWrapper.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._config.ConfigWrapper","values":[],"variance":0},"slots":["config_dict"],"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ConfigWrapperStack":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._config.ConfigWrapperStack","name":"ConfigWrapperStack","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._config.ConfigWrapperStack","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic._internal._config","mro":["pydantic._internal._config.ConfigWrapperStack","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","config_wrapper"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._config.ConfigWrapperStack.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","config_wrapper"],"arg_types":["pydantic._internal._config.ConfigWrapperStack","pydantic._internal._config.ConfigWrapper"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of ConfigWrapperStack","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_config_wrapper_stack":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic._internal._config.ConfigWrapperStack._config_wrapper_stack","name":"_config_wrapper_stack","setter_type":null,"type":{".class":"Instance","args":["pydantic._internal._config.ConfigWrapper"],"extra_attrs":null,"type_ref":"builtins.list"}}},"push":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","config_wrapper"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated","is_trivial_self"],"fullname":"pydantic._internal._config.ConfigWrapperStack.push","name":"push","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","config_wrapper"],"arg_types":["pydantic._internal._config.ConfigWrapperStack",{".class":"UnionType","items":["pydantic._internal._config.ConfigWrapper",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.config.ConfigDict"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"push of ConfigWrapperStack","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred"],"fullname":"pydantic._internal._config.ConfigWrapperStack.push","name":"push","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","config_wrapper"],"arg_types":["pydantic._internal._config.ConfigWrapperStack",{".class":"UnionType","items":["pydantic._internal._config.ConfigWrapper",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.config.ConfigDict"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"push of ConfigWrapperStack","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_of_any":7},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"tail":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"pydantic._internal._config.ConfigWrapperStack.tail","name":"tail","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._config.ConfigWrapperStack"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tail of ConfigWrapperStack","ret_type":"pydantic._internal._config.ConfigWrapper","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"pydantic._internal._config.ConfigWrapperStack.tail","name":"tail","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._config.ConfigWrapperStack"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tail of ConfigWrapperStack","ret_type":"pydantic._internal._config.ConfigWrapper","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._config.ConfigWrapperStack.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._config.ConfigWrapperStack","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"DEPRECATION_MESSAGE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._config.DEPRECATION_MESSAGE","name":"DEPRECATION_MESSAGE","setter_type":null,"type":"builtins.str"}},"ExtraValues":{".class":"SymbolTableNode","cross_ref":"pydantic.config.ExtraValues","kind":"Gdef"},"FieldInfo":{".class":"SymbolTableNode","cross_ref":"pydantic.fields.FieldInfo","kind":"Gdef"},"GenerateSchema":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._generate_schema.GenerateSchema","kind":"Gdef"},"JsonDict":{".class":"SymbolTableNode","cross_ref":"pydantic.config.JsonDict","kind":"Gdef"},"JsonEncoder":{".class":"SymbolTableNode","cross_ref":"pydantic.config.JsonEncoder","kind":"Gdef"},"JsonSchemaExtraCallable":{".class":"SymbolTableNode","cross_ref":"pydantic.config.JsonSchemaExtraCallable","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"Pattern":{".class":"SymbolTableNode","cross_ref":"re.Pattern","kind":"Gdef"},"PydanticDeprecatedSince20":{".class":"SymbolTableNode","cross_ref":"pydantic.warnings.PydanticDeprecatedSince20","kind":"Gdef"},"PydanticDeprecatedSince210":{".class":"SymbolTableNode","cross_ref":"pydantic.warnings.PydanticDeprecatedSince210","kind":"Gdef"},"PydanticUserError":{".class":"SymbolTableNode","cross_ref":"pydantic.errors.PydanticUserError","kind":"Gdef"},"Self":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Self","kind":"Gdef"},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"V2_REMOVED_KEYS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._config.V2_REMOVED_KEYS","name":"V2_REMOVED_KEYS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"V2_RENAMED_KEYS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._config.V2_RENAMED_KEYS","name":"V2_RENAMED_KEYS","setter_type":null,"type":{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._config.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._config.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._config.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._config.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._config.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._config.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"cast":{".class":"SymbolTableNode","cross_ref":"typing.cast","kind":"Gdef"},"check_deprecated":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["config_dict"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._config.check_deprecated","name":"check_deprecated","original_first_arg":"config_dict","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["config_dict"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.config.ConfigDict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"check_deprecated","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"config_defaults":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._config.config_defaults","name":"config_defaults","setter_type":null,"type":{".class":"TypedDictType","fallback":"pydantic.config.ConfigDict","items":[["title",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],["model_title_generator",{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.type"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":true}],["field_title_generator",{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["builtins.str",{".class":"UnionType","items":["pydantic.fields.FieldInfo","pydantic.fields.ComputedFieldInfo"],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":true}],["str_to_lower","builtins.bool"],["str_to_upper","builtins.bool"],["str_strip_whitespace","builtins.bool"],["str_min_length","builtins.int"],["str_max_length",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],["extra",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.config.ExtraValues"},{".class":"NoneType"}],"uses_pep604_syntax":true}],["frozen","builtins.bool"],["populate_by_name","builtins.bool"],["use_enum_values","builtins.bool"],["validate_assignment","builtins.bool"],["arbitrary_types_allowed","builtins.bool"],["from_attributes","builtins.bool"],["loc_by_alias","builtins.bool"],["alias_generator",{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"pydantic.aliases.AliasGenerator",{".class":"NoneType"}],"uses_pep604_syntax":true}],["ignored_types",{".class":"Instance","args":["builtins.type"],"extra_attrs":null,"type_ref":"builtins.tuple"}],["allow_inf_nan","builtins.bool"],["json_schema_extra",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.config.JsonDict"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.config.JsonSchemaExtraCallable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],["json_encoders",{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeType","item":"builtins.object"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.config.JsonEncoder"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}],["strict","builtins.bool"],["revalidate_instances",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"always"},{".class":"LiteralType","fallback":"builtins.str","value":"never"},{".class":"LiteralType","fallback":"builtins.str","value":"subclass-instances"}],"uses_pep604_syntax":false}],["ser_json_timedelta",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"iso8601"},{".class":"LiteralType","fallback":"builtins.str","value":"float"}],"uses_pep604_syntax":false}],["ser_json_temporal",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"iso8601"},{".class":"LiteralType","fallback":"builtins.str","value":"seconds"},{".class":"LiteralType","fallback":"builtins.str","value":"milliseconds"}],"uses_pep604_syntax":false}],["val_temporal_unit",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"seconds"},{".class":"LiteralType","fallback":"builtins.str","value":"milliseconds"},{".class":"LiteralType","fallback":"builtins.str","value":"infer"}],"uses_pep604_syntax":false}],["ser_json_bytes",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"utf8"},{".class":"LiteralType","fallback":"builtins.str","value":"base64"},{".class":"LiteralType","fallback":"builtins.str","value":"hex"}],"uses_pep604_syntax":false}],["val_json_bytes",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"utf8"},{".class":"LiteralType","fallback":"builtins.str","value":"base64"},{".class":"LiteralType","fallback":"builtins.str","value":"hex"}],"uses_pep604_syntax":false}],["ser_json_inf_nan",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"null"},{".class":"LiteralType","fallback":"builtins.str","value":"constants"},{".class":"LiteralType","fallback":"builtins.str","value":"strings"}],"uses_pep604_syntax":false}],["validate_default","builtins.bool"],["validate_return","builtins.bool"],["protected_namespaces",{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}],["hide_input_in_errors","builtins.bool"],["defer_build","builtins.bool"],["plugin_settings",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","builtins.object"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}],["schema_generator",{".class":"UnionType","items":[{".class":"TypeType","item":"pydantic._internal._generate_schema.GenerateSchema"},{".class":"NoneType"}],"uses_pep604_syntax":true}],["json_schema_serialization_defaults_required","builtins.bool"],["json_schema_mode_override",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"validation"},{".class":"LiteralType","fallback":"builtins.str","value":"serialization"},{".class":"NoneType"}],"uses_pep604_syntax":false}],["coerce_numbers_to_str","builtins.bool"],["regex_engine",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"rust-regex"},{".class":"LiteralType","fallback":"builtins.str","value":"python-re"}],"uses_pep604_syntax":false}],["validation_error_cause","builtins.bool"],["use_attribute_docstrings","builtins.bool"],["cache_strings",{".class":"UnionType","items":["builtins.bool",{".class":"LiteralType","fallback":"builtins.str","value":"all"},{".class":"LiteralType","fallback":"builtins.str","value":"keys"},{".class":"LiteralType","fallback":"builtins.str","value":"none"}],"uses_pep604_syntax":true}],["validate_by_alias","builtins.bool"],["validate_by_name","builtins.bool"],["serialize_by_alias","builtins.bool"],["url_preserve_empty_path","builtins.bool"]],"readonly_keys":[],"required_keys":[]}}},"config_keys":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._config.config_keys","name":"config_keys","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"contextmanager":{".class":"SymbolTableNode","cross_ref":"contextlib.contextmanager","kind":"Gdef"},"core_schema":{".class":"SymbolTableNode","cross_ref":"pydantic_core.core_schema","kind":"Gdef"},"prepare_config":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["config"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._config.prepare_config","name":"prepare_config","original_first_arg":"config","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["config"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.config.ConfigDict"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prepare_config","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.config.ConfigDict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"warnings":{".class":"SymbolTableNode","cross_ref":"warnings","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_config.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_config.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_config.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..2649ecdbbc990c52670234dd5a2b15b7440c75a2 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_config.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[23,14,17,18,19,20,24,1,3,4,5,6,14,15,1,1,1,1,1,1],"dep_prios":[25,10,5,5,5,5,25,5,10,5,5,5,20,5,5,30,30,30,30,30],"dependencies":["pydantic._internal._schema_generation_shared","pydantic_core.core_schema","pydantic.aliases","pydantic.config","pydantic.errors","pydantic.warnings","pydantic.fields","__future__","warnings","contextlib","re","typing","pydantic_core","typing_extensions","builtins","_collections_abc","_frozen_importlib","abc","pydantic._internal._generate_schema","pydantic._internal._repr"],"hash":"23ba9a9a2c0137d3e0d19f800829348ff06d17ae","id":"pydantic._internal._config","ignore_all":true,"interface_hash":"1ab254618bf9578ac42176d7a781842f97c4e786","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_config.py","plugin_data":null,"size":14674,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_core_metadata.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_core_metadata.data.json new file mode 100644 index 0000000000000000000000000000000000000000..7490d807a9880601c295af3896491ded71965bf5 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_core_metadata.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic._internal._core_metadata","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"CoreMetadata":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._core_metadata.CoreMetadata","name":"CoreMetadata","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._core_metadata.CoreMetadata","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic._internal._core_metadata","mro":["pydantic._internal._core_metadata.CoreMetadata","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["pydantic_js_functions",{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._schema_generation_shared.GetJsonSchemaFunction"}],"extra_attrs":null,"type_ref":"builtins.list"}],["pydantic_js_annotation_functions",{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._schema_generation_shared.GetJsonSchemaFunction"}],"extra_attrs":null,"type_ref":"builtins.list"}],["pydantic_js_prefer_positional_arguments","builtins.bool"],["pydantic_js_updates",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.config.JsonDict"}],["pydantic_js_extra",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.config.JsonDict"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.config.JsonSchemaExtraCallable"}],"uses_pep604_syntax":true}],["pydantic_internal_union_tag_key","builtins.str"],["pydantic_internal_union_discriminator","builtins.str"]],"readonly_keys":[],"required_keys":[]}}},"GetJsonSchemaFunction":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._schema_generation_shared.GetJsonSchemaFunction","kind":"Gdef"},"JsonDict":{".class":"SymbolTableNode","cross_ref":"pydantic.config.JsonDict","kind":"Gdef"},"JsonSchemaExtraCallable":{".class":"SymbolTableNode","cross_ref":"pydantic.config.JsonSchemaExtraCallable","kind":"Gdef"},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"TypedDict":{".class":"SymbolTableNode","cross_ref":"typing.TypedDict","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._core_metadata.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._core_metadata.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._core_metadata.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._core_metadata.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._core_metadata.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._core_metadata.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"cast":{".class":"SymbolTableNode","cross_ref":"typing.cast","kind":"Gdef"},"update_core_metadata":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5],"arg_names":[null,"pydantic_js_functions","pydantic_js_annotation_functions","pydantic_js_updates","pydantic_js_extra"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._core_metadata.update_core_metadata","name":"update_core_metadata","original_first_arg":"core_metadata","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":[null,"pydantic_js_functions","pydantic_js_annotation_functions","pydantic_js_updates","pydantic_js_extra"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._schema_generation_shared.GetJsonSchemaFunction"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._schema_generation_shared.GetJsonSchemaFunction"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.config.JsonDict"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.config.JsonDict"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.config.JsonSchemaExtraCallable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"update_core_metadata","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"warn":{".class":"SymbolTableNode","cross_ref":"_warnings.warn","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_core_metadata.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_core_metadata.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_core_metadata.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..9710bcd13e32cbabcba3c626aad14b38e37cd05e --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_core_metadata.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[8,7,1,3,4,1,1,1,1,1,1],"dep_prios":[25,25,5,5,5,5,30,30,30,30,30],"dependencies":["pydantic._internal._schema_generation_shared","pydantic.config","__future__","typing","warnings","builtins","_frozen_importlib","abc","pydantic.annotated_handlers","pydantic_core","pydantic_core.core_schema"],"hash":"d887524bee3f01b397ddd60c35403e4efc5791d9","id":"pydantic._internal._core_metadata","ignore_all":true,"interface_hash":"1d750f680669cb26f3e2d9296f3e003ca0aaed08","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_core_metadata.py","plugin_data":null,"size":5162,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_core_utils.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_core_utils.data.json new file mode 100644 index 0000000000000000000000000000000000000000..637ecf6556e3f8a623cb1e8642b975adaae23860 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_core_utils.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic._internal._core_utils","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"AnyFunctionSchema":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic._internal._core_utils.AnyFunctionSchema","line":17,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.AfterValidatorFunctionSchema"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.BeforeValidatorFunctionSchema"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.WrapValidatorFunctionSchema"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.PlainValidatorFunctionSchema"}],"uses_pep604_syntax":false}}},"Console":{".class":"SymbolTableNode","cross_ref":"rich.console.Console","kind":"Gdef"},"CoreSchema":{".class":"SymbolTableNode","cross_ref":"pydantic_core.core_schema.CoreSchema","kind":"Gdef"},"CoreSchemaField":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic._internal._core_utils.CoreSchemaField","line":31,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.ModelField"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.DataclassField"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.TypedDictField"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.ComputedField"}],"uses_pep604_syntax":false}}},"CoreSchemaOrField":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic._internal._core_utils.CoreSchemaOrField","line":34,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._core_utils.CoreSchemaField"}],"uses_pep604_syntax":false}}},"FunctionSchemaWithInnerSchema":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic._internal._core_utils.FunctionSchemaWithInnerSchema","line":25,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.AfterValidatorFunctionSchema"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.BeforeValidatorFunctionSchema"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.WrapValidatorFunctionSchema"}],"uses_pep604_syntax":false}}},"Mapping":{".class":"SymbolTableNode","cross_ref":"typing.Mapping","kind":"Gdef"},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef"},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"TypeGuard":{".class":"SymbolTableNode","cross_ref":"typing_extensions.TypeGuard","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"_CORE_SCHEMA_FIELD_TYPES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._core_utils._CORE_SCHEMA_FIELD_TYPES","name":"_CORE_SCHEMA_FIELD_TYPES","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"_FUNCTION_WITH_INNER_SCHEMA_TYPES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._core_utils._FUNCTION_WITH_INNER_SCHEMA_TYPES","name":"_FUNCTION_WITH_INNER_SCHEMA_TYPES","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"_LIST_LIKE_SCHEMA_WITH_ITEMS_TYPES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._core_utils._LIST_LIKE_SCHEMA_WITH_ITEMS_TYPES","name":"_LIST_LIKE_SCHEMA_WITH_ITEMS_TYPES","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._core_utils.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._core_utils.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._core_utils.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._core_utils.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._core_utils.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._core_utils.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_clean_schema_for_pretty_print":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["obj","strip_metadata"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._core_utils._clean_schema_for_pretty_print","name":"_clean_schema_for_pretty_print","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["obj","strip_metadata"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_clean_schema_for_pretty_print","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_repr":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._repr","kind":"Gdef"},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"core_schema":{".class":"SymbolTableNode","cross_ref":"pydantic_core.core_schema","kind":"Gdef"},"get_args":{".class":"SymbolTableNode","cross_ref":"typing_extensions.get_args","kind":"Gdef"},"get_origin":{".class":"SymbolTableNode","cross_ref":"typing_extensions.get_origin","kind":"Gdef"},"get_ref":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["s"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._core_utils.get_ref","name":"get_ref","original_first_arg":"s","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["s"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_ref","ret_type":{".class":"UnionType","items":[{".class":"NoneType"},"builtins.str"],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_type_ref":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["type_","args_override"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._core_utils.get_type_ref","name":"get_type_ref","original_first_arg":"type_","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["type_","args_override"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_type_ref","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"inspect":{".class":"SymbolTableNode","cross_ref":"inspect","kind":"Gdef"},"is_core_schema":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["schema"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._core_utils.is_core_schema","name":"is_core_schema","original_first_arg":"schema","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["schema"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._core_utils.CoreSchemaOrField"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_core_schema","ret_type":"builtins.bool","type_guard":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_core_schema_field":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["schema"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._core_utils.is_core_schema_field","name":"is_core_schema_field","original_first_arg":"schema","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["schema"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._core_utils.CoreSchemaOrField"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_core_schema_field","ret_type":"builtins.bool","type_guard":{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._core_utils.CoreSchemaField"},"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_function_with_inner_schema":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["schema"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._core_utils.is_function_with_inner_schema","name":"is_function_with_inner_schema","original_first_arg":"schema","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["schema"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._core_utils.CoreSchemaOrField"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_function_with_inner_schema","ret_type":"builtins.bool","type_guard":{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._core_utils.FunctionSchemaWithInnerSchema"},"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_generic_alias":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._typing_extra.is_generic_alias","kind":"Gdef"},"is_list_like_schema_with_items_schema":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["schema"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._core_utils.is_list_like_schema_with_items_schema","name":"is_list_like_schema_with_items_schema","original_first_arg":"schema","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["schema"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_list_like_schema_with_items_schema","ret_type":"builtins.bool","type_guard":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.ListSchema"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.SetSchema"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.FrozenSetSchema"}],"uses_pep604_syntax":true},"type_is":null,"unpack_kwargs":false,"variables":[]}}},"pps":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._core_utils.pps","name":"pps","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":["val","console","max_depth","strip_metadata"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["rich.console.Console",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"pretty_print_core_schema":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5],"arg_names":["val","console","max_depth","strip_metadata"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._core_utils.pretty_print_core_schema","name":"pretty_print_core_schema","original_first_arg":"val","type":{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":["val","console","max_depth","strip_metadata"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["rich.console.Console",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pretty_print_core_schema","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"typing_objects":{".class":"SymbolTableNode","cross_ref":"typing_inspection.typing_objects","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_core_utils.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_core_utils.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_core_utils.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..0bf79d97babf64c22dc2923c781142d9dfc00a03 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_core_utils.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[11,12,4,7,9,11,15,1,3,5,7,8,9,1,1,1,1],"dep_prios":[10,5,5,10,10,20,25,5,10,5,5,5,20,5,30,30,30],"dependencies":["pydantic._internal._repr","pydantic._internal._typing_extra","collections.abc","pydantic_core.core_schema","typing_inspection.typing_objects","pydantic._internal","rich.console","__future__","inspect","typing","pydantic_core","typing_extensions","typing_inspection","builtins","_frozen_importlib","abc","rich"],"hash":"c37efe0f82cd4f4a6228a31cd0df76568093ae76","id":"pydantic._internal._core_utils","ignore_all":true,"interface_hash":"0fcad2bc96536c50a27b47b1200514100f3cd4bd","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_core_utils.py","plugin_data":null,"size":6487,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_dataclasses.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_dataclasses.data.json new file mode 100644 index 0000000000000000000000000000000000000000..67f62e3bb24007ca6a92bd1a73fdd5b2ab05fec9 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_dataclasses.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic._internal._dataclasses","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"ArgsKwargs":{".class":"SymbolTableNode","cross_ref":"pydantic_core._pydantic_core.ArgsKwargs","kind":"Gdef"},"ClassVar":{".class":"SymbolTableNode","cross_ref":"typing.ClassVar","kind":"Gdef"},"ConfigDict":{".class":"SymbolTableNode","cross_ref":"pydantic.config.ConfigDict","kind":"Gdef"},"DcFields":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic._internal._dataclasses.DcFields","line":226,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"dataclasses.Field"}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"FieldInfo":{".class":"SymbolTableNode","cross_ref":"pydantic.fields.FieldInfo","kind":"Gdef"},"GenerateSchema":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._generate_schema.GenerateSchema","kind":"Gdef"},"Generator":{".class":"SymbolTableNode","cross_ref":"typing.Generator","kind":"Gdef"},"InvalidSchemaError":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._generate_schema.InvalidSchemaError","kind":"Gdef"},"LazyClassAttribute":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._utils.LazyClassAttribute","kind":"Gdef"},"NsResolver":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._namespace_utils.NsResolver","kind":"Gdef"},"PluggableSchemaValidator":{".class":"SymbolTableNode","cross_ref":"pydantic.plugin._schema_validator.PluggableSchemaValidator","kind":"Gdef"},"Protocol":{".class":"SymbolTableNode","cross_ref":"typing.Protocol","kind":"Gdef"},"PydanticDataclass":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[["__dataclass_fields__",1],["__pydantic_complete__",1],["__pydantic_config__",1],["__pydantic_core_schema__",1],["__pydantic_decorators__",1],["__pydantic_fields__",1],["__pydantic_fields_complete__",2],["__pydantic_serializer__",1],["__pydantic_validator__",1]],"alt_promote":null,"bases":["_typeshed.DataclassInstance"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._dataclasses.PydanticDataclass","name":"PydanticDataclass","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_abstract","is_protocol"],"fullname":"pydantic._internal._dataclasses.PydanticDataclass","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic._internal._dataclasses","mro":["pydantic._internal._dataclasses.PydanticDataclass","_typeshed.DataclassInstance","builtins.object"],"names":{".class":"SymbolTable","__pydantic_complete__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_abstract_var","is_ready"],"fullname":"pydantic._internal._dataclasses.PydanticDataclass.__pydantic_complete__","name":"__pydantic_complete__","setter_type":null,"type":"builtins.bool"}},"__pydantic_config__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_abstract_var","is_ready"],"fullname":"pydantic._internal._dataclasses.PydanticDataclass.__pydantic_config__","name":"__pydantic_config__","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.config.ConfigDict"}}},"__pydantic_core_schema__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_abstract_var","is_ready"],"fullname":"pydantic._internal._dataclasses.PydanticDataclass.__pydantic_core_schema__","name":"__pydantic_core_schema__","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"}}},"__pydantic_decorators__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_abstract_var","is_ready"],"fullname":"pydantic._internal._dataclasses.PydanticDataclass.__pydantic_decorators__","name":"__pydantic_decorators__","setter_type":null,"type":"pydantic._internal._decorators.DecoratorInfos"}},"__pydantic_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_abstract_var","is_ready"],"fullname":"pydantic._internal._dataclasses.PydanticDataclass.__pydantic_fields__","name":"__pydantic_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str","pydantic.fields.FieldInfo"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__pydantic_fields_complete__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_body","is_trivial_self","is_mypy_only"],"fullname":"pydantic._internal._dataclasses.PydanticDataclass.__pydantic_fields_complete__","name":"__pydantic_fields_complete__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic._internal._dataclasses.PydanticDataclass"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__pydantic_fields_complete__ of PydanticDataclass","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic._internal._dataclasses.PydanticDataclass.__pydantic_fields_complete__","name":"__pydantic_fields_complete__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic._internal._dataclasses.PydanticDataclass"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__pydantic_fields_complete__ of PydanticDataclass","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__pydantic_serializer__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_abstract_var","is_ready"],"fullname":"pydantic._internal._dataclasses.PydanticDataclass.__pydantic_serializer__","name":"__pydantic_serializer__","setter_type":null,"type":"pydantic_core._pydantic_core.SchemaSerializer"}},"__pydantic_validator__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_abstract_var","is_ready"],"fullname":"pydantic._internal._dataclasses.PydanticDataclass.__pydantic_validator__","name":"__pydantic_validator__","setter_type":null,"type":{".class":"UnionType","items":["pydantic_core._pydantic_core.SchemaValidator","pydantic.plugin._schema_validator.PluggableSchemaValidator"],"uses_pep604_syntax":true}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._dataclasses.PydanticDataclass.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._dataclasses.PydanticDataclass","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"PydanticDeprecatedSince20":{".class":"SymbolTableNode","cross_ref":"pydantic.warnings.PydanticDeprecatedSince20","kind":"Gdef"},"PydanticUndefinedAnnotation":{".class":"SymbolTableNode","cross_ref":"pydantic.errors.PydanticUndefinedAnnotation","kind":"Gdef"},"SchemaSerializer":{".class":"SymbolTableNode","cross_ref":"pydantic_core._pydantic_core.SchemaSerializer","kind":"Gdef"},"SchemaValidator":{".class":"SymbolTableNode","cross_ref":"pydantic_core._pydantic_core.SchemaValidator","kind":"Gdef"},"StandardDataclass":{".class":"SymbolTableNode","cross_ref":"_typeshed.DataclassInstance","kind":"Gdef"},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"TypeAlias":{".class":"SymbolTableNode","cross_ref":"typing_extensions.TypeAlias","kind":"Gdef"},"TypeIs":{".class":"SymbolTableNode","cross_ref":"typing_extensions.TypeIs","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._dataclasses.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._dataclasses.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._dataclasses.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._dataclasses.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._dataclasses.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._dataclasses.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"_config":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._config","kind":"Gdef"},"_decorators":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._decorators","kind":"Gdef"},"as_dataclass_field":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["pydantic_field"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._dataclasses.as_dataclass_field","name":"as_dataclass_field","original_first_arg":"pydantic_field","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["pydantic_field"],"arg_types":["pydantic.fields.FieldInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_dataclass_field","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"dataclasses.Field"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"cast":{".class":"SymbolTableNode","cross_ref":"typing.cast","kind":"Gdef"},"collect_dataclass_fields":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._fields.collect_dataclass_fields","kind":"Gdef"},"complete_dataclass":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5],"arg_names":["cls","config_wrapper","raise_errors","ns_resolver","_force_build"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._dataclasses.complete_dataclass","name":"complete_dataclass","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5],"arg_names":["cls","config_wrapper","raise_errors","ns_resolver","_force_build"],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},"pydantic._internal._config.ConfigWrapper","builtins.bool",{".class":"UnionType","items":["pydantic._internal._namespace_utils.NsResolver",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"complete_dataclass","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"contextmanager":{".class":"SymbolTableNode","cross_ref":"contextlib.contextmanager","kind":"Gdef"},"copy":{".class":"SymbolTableNode","cross_ref":"copy","kind":"Gdef"},"core_schema":{".class":"SymbolTableNode","cross_ref":"pydantic_core.core_schema","kind":"Gdef"},"create_schema_validator":{".class":"SymbolTableNode","cross_ref":"pydantic.plugin._schema_validator.create_schema_validator","kind":"Gdef"},"dataclasses":{".class":"SymbolTableNode","cross_ref":"dataclasses","kind":"Gdef"},"generate_pydantic_signature":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._signature.generate_pydantic_signature","kind":"Gdef"},"get_standard_typevars_map":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._generics.get_standard_typevars_map","kind":"Gdef"},"is_stdlib_dataclass":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._dataclasses.is_stdlib_dataclass","name":"is_stdlib_dataclass","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_stdlib_dataclass","ret_type":"builtins.bool","type_guard":null,"type_is":{".class":"TypeType","item":"_typeshed.DataclassInstance"},"unpack_kwargs":false,"variables":[]}}},"partial":{".class":"SymbolTableNode","cross_ref":"functools.partial","kind":"Gdef"},"patch_base_fields":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated"],"fullname":"pydantic._internal._dataclasses.patch_base_fields","name":"patch_base_fields","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"patch_base_fields","ret_type":{".class":"Instance","args":[{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Generator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._dataclasses.patch_base_fields","name":"patch_base_fields","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"patch_base_fields","ret_type":{".class":"Instance","args":[{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"set_dataclass_fields":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["cls","config_wrapper","ns_resolver"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._dataclasses.set_dataclass_fields","name":"set_dataclass_fields","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["cls","config_wrapper","ns_resolver"],"arg_types":[{".class":"TypeType","item":"_typeshed.DataclassInstance"},"pydantic._internal._config.ConfigWrapper",{".class":"UnionType","items":["pydantic._internal._namespace_utils.NsResolver",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"set_dataclass_fields","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"set_dataclass_mocks":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._mock_val_ser.set_dataclass_mocks","kind":"Gdef"},"sys":{".class":"SymbolTableNode","cross_ref":"sys","kind":"Gdef"},"warnings":{".class":"SymbolTableNode","cross_ref":"warnings","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_dataclasses.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_dataclasses.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_dataclasses.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..f9b0da42f83012d0d7bf2768b9e4e89f1d47bf45 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_dataclasses.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[24,26,26,27,28,29,30,31,32,33,9,14,22,23,25,26,38,3,5,6,7,8,10,11,12,14,20,36,1,1,1,1,1,1,1,1],"dep_prios":[5,10,10,5,5,5,5,5,5,5,5,10,5,5,5,20,25,5,10,10,10,10,5,5,5,5,5,25,5,30,30,30,30,30,30,30],"dependencies":["pydantic.plugin._schema_validator","pydantic._internal._config","pydantic._internal._decorators","pydantic._internal._fields","pydantic._internal._generate_schema","pydantic._internal._generics","pydantic._internal._mock_val_ser","pydantic._internal._namespace_utils","pydantic._internal._signature","pydantic._internal._utils","collections.abc","pydantic_core.core_schema","pydantic.errors","pydantic.fields","pydantic.warnings","pydantic._internal","pydantic.config","__future__","copy","dataclasses","sys","warnings","contextlib","functools","typing","pydantic_core","typing_extensions","_typeshed","builtins","_frozen_importlib","abc","pydantic._internal._repr","pydantic.aliases","pydantic.plugin","pydantic_core._pydantic_core","re"],"hash":"355c51d5f74295dc477267b2d758bae77cdda30d","id":"pydantic._internal._dataclasses","ignore_all":true,"interface_hash":"77a9d5489ba986016c4b4d49feb0ff544110c338","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_dataclasses.py","plugin_data":null,"size":13158,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_decorators.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_decorators.data.json new file mode 100644 index 0000000000000000000000000000000000000000..85f489ef66857dae5c983963585b1430713f4c44 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_decorators.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic._internal._decorators","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"AnyDecoratorCallable":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic._internal._decorators.AnyDecoratorCallable","line":680,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.classmethod"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.staticmethod"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"functools.partialmethod"},{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"uses_pep604_syntax":false}}},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"ClassVar":{".class":"SymbolTableNode","cross_ref":"typing.ClassVar","kind":"Gdef"},"ComputedFieldInfo":{".class":"SymbolTableNode","cross_ref":"pydantic.fields.ComputedFieldInfo","kind":"Gdef"},"ConfigWrapper":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._config.ConfigWrapper","kind":"Gdef"},"DecoratedType":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.ReturnType","id":1,"name":"ReturnType","namespace":"pydantic._internal._decorators.DecoratedType","upper_bound":"builtins.object","values":[],"variance":0}],"column":0,"fullname":"pydantic._internal._decorators.DecoratedType","line":159,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.ReturnType","id":1,"name":"ReturnType","namespace":"pydantic._internal._decorators.DecoratedType","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.classmethod"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.ReturnType","id":1,"name":"ReturnType","namespace":"pydantic._internal._decorators.DecoratedType","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.staticmethod"},{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.ReturnType","id":1,"name":"ReturnType","namespace":"pydantic._internal._decorators.DecoratedType","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"builtins.property"],"uses_pep604_syntax":false}}},"Decorator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._decorators.Decorator","name":"Decorator","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.DecoratorInfoType","id":1,"name":"DecoratorInfoType","namespace":"pydantic._internal._decorators.Decorator","upper_bound":{".class":"UnionType","items":["pydantic._internal._decorators.ValidatorDecoratorInfo","pydantic._internal._decorators.FieldValidatorDecoratorInfo","pydantic._internal._decorators.RootValidatorDecoratorInfo","pydantic._internal._decorators.FieldSerializerDecoratorInfo","pydantic._internal._decorators.ModelSerializerDecoratorInfo","pydantic._internal._decorators.ModelValidatorDecoratorInfo","pydantic.fields.ComputedFieldInfo"],"uses_pep604_syntax":false},"values":[],"variance":0}]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators.Decorator","has_param_spec_type":false,"metaclass_type":null,"metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":233,"name":"cls_ref","type":"builtins.str"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":234,"name":"cls_var_name","type":"builtins.str"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":235,"name":"func","type":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":236,"name":"shim","type":{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":237,"name":"info","type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.DecoratorInfoType","id":1,"name":"DecoratorInfoType","namespace":"pydantic._internal._decorators.Decorator","upper_bound":{".class":"UnionType","items":["pydantic._internal._decorators.ValidatorDecoratorInfo","pydantic._internal._decorators.FieldValidatorDecoratorInfo","pydantic._internal._decorators.RootValidatorDecoratorInfo","pydantic._internal._decorators.FieldSerializerDecoratorInfo","pydantic._internal._decorators.ModelSerializerDecoratorInfo","pydantic._internal._decorators.ModelValidatorDecoratorInfo","pydantic.fields.ComputedFieldInfo"],"uses_pep604_syntax":false},"values":[],"variance":0}}],"frozen":false},"dataclass_tag":{}},"module_name":"pydantic._internal._decorators","mro":["pydantic._internal._decorators.Decorator","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"pydantic._internal._decorators.Decorator.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"dataclasses.Field"}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0,0],"arg_names":["self","cls_ref","cls_var_name","func","shim","info"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators.Decorator.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0],"arg_names":["self","cls_ref","cls_var_name","func","shim","info"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.DecoratorInfoType","id":1,"name":"DecoratorInfoType","namespace":"pydantic._internal._decorators.Decorator","upper_bound":{".class":"UnionType","items":["pydantic._internal._decorators.ValidatorDecoratorInfo","pydantic._internal._decorators.FieldValidatorDecoratorInfo","pydantic._internal._decorators.RootValidatorDecoratorInfo","pydantic._internal._decorators.FieldSerializerDecoratorInfo","pydantic._internal._decorators.ModelSerializerDecoratorInfo","pydantic._internal._decorators.ModelValidatorDecoratorInfo","pydantic.fields.ComputedFieldInfo"],"uses_pep604_syntax":false},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"},"builtins.str","builtins.str",{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.DecoratorInfoType","id":1,"name":"DecoratorInfoType","namespace":"pydantic._internal._decorators.Decorator","upper_bound":{".class":"UnionType","items":["pydantic._internal._decorators.ValidatorDecoratorInfo","pydantic._internal._decorators.FieldValidatorDecoratorInfo","pydantic._internal._decorators.RootValidatorDecoratorInfo","pydantic._internal._decorators.FieldSerializerDecoratorInfo","pydantic._internal._decorators.ModelSerializerDecoratorInfo","pydantic._internal._decorators.ModelValidatorDecoratorInfo","pydantic.fields.ComputedFieldInfo"],"uses_pep604_syntax":false},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of Decorator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5],"arg_names":["cls_ref","cls_var_name","func","shim","info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"pydantic._internal._decorators.Decorator.__mypy-replace","name":"__mypy-replace","original_first_arg":"cls_ref","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5],"arg_names":["cls_ref","cls_var_name","func","shim","info"],"arg_types":["builtins.str","builtins.str",{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.DecoratorInfoType","id":1,"name":"DecoratorInfoType","namespace":"pydantic._internal._decorators.Decorator","upper_bound":{".class":"UnionType","items":["pydantic._internal._decorators.ValidatorDecoratorInfo","pydantic._internal._decorators.FieldValidatorDecoratorInfo","pydantic._internal._decorators.RootValidatorDecoratorInfo","pydantic._internal._decorators.FieldSerializerDecoratorInfo","pydantic._internal._decorators.ModelSerializerDecoratorInfo","pydantic._internal._decorators.ModelValidatorDecoratorInfo","pydantic.fields.ComputedFieldInfo"],"uses_pep604_syntax":false},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of Decorator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"pydantic._internal._decorators.Decorator.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5],"arg_names":["cls_ref","cls_var_name","func","shim","info"],"arg_types":["builtins.str","builtins.str",{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.DecoratorInfoType","id":1,"name":"DecoratorInfoType","namespace":"pydantic._internal._decorators.Decorator","upper_bound":{".class":"UnionType","items":["pydantic._internal._decorators.ValidatorDecoratorInfo","pydantic._internal._decorators.FieldValidatorDecoratorInfo","pydantic._internal._decorators.RootValidatorDecoratorInfo","pydantic._internal._decorators.FieldSerializerDecoratorInfo","pydantic._internal._decorators.ModelSerializerDecoratorInfo","pydantic._internal._decorators.ModelValidatorDecoratorInfo","pydantic.fields.ComputedFieldInfo"],"uses_pep604_syntax":false},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of Decorator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"bind_to_cls":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._decorators.Decorator.bind_to_cls","name":"bind_to_cls","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","cls"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.DecoratorInfoType","id":1,"name":"DecoratorInfoType","namespace":"pydantic._internal._decorators.Decorator","upper_bound":{".class":"UnionType","items":["pydantic._internal._decorators.ValidatorDecoratorInfo","pydantic._internal._decorators.FieldValidatorDecoratorInfo","pydantic._internal._decorators.RootValidatorDecoratorInfo","pydantic._internal._decorators.FieldSerializerDecoratorInfo","pydantic._internal._decorators.ModelSerializerDecoratorInfo","pydantic._internal._decorators.ModelValidatorDecoratorInfo","pydantic.fields.ComputedFieldInfo"],"uses_pep604_syntax":false},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"bind_to_cls of Decorator","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.DecoratorInfoType","id":1,"name":"DecoratorInfoType","namespace":"pydantic._internal._decorators.Decorator","upper_bound":{".class":"UnionType","items":["pydantic._internal._decorators.ValidatorDecoratorInfo","pydantic._internal._decorators.FieldValidatorDecoratorInfo","pydantic._internal._decorators.RootValidatorDecoratorInfo","pydantic._internal._decorators.FieldSerializerDecoratorInfo","pydantic._internal._decorators.ModelSerializerDecoratorInfo","pydantic._internal._decorators.ModelValidatorDecoratorInfo","pydantic.fields.ComputedFieldInfo"],"uses_pep604_syntax":false},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"build":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,3,3],"arg_names":["cls_","cls_var_name","shim","info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"pydantic._internal._decorators.Decorator.build","name":"build","original_first_arg":"cls_","type":{".class":"CallableType","arg_kinds":[0,3,3,3],"arg_names":["cls_","cls_var_name","shim","info"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"builtins.str",{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.DecoratorInfoType","id":1,"name":"DecoratorInfoType","namespace":"pydantic._internal._decorators.Decorator","upper_bound":{".class":"UnionType","items":["pydantic._internal._decorators.ValidatorDecoratorInfo","pydantic._internal._decorators.FieldValidatorDecoratorInfo","pydantic._internal._decorators.RootValidatorDecoratorInfo","pydantic._internal._decorators.FieldSerializerDecoratorInfo","pydantic._internal._decorators.ModelSerializerDecoratorInfo","pydantic._internal._decorators.ModelValidatorDecoratorInfo","pydantic.fields.ComputedFieldInfo"],"uses_pep604_syntax":false},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"build of Decorator","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.DecoratorInfoType","id":1,"name":"DecoratorInfoType","namespace":"pydantic._internal._decorators.Decorator","upper_bound":{".class":"UnionType","items":["pydantic._internal._decorators.ValidatorDecoratorInfo","pydantic._internal._decorators.FieldValidatorDecoratorInfo","pydantic._internal._decorators.RootValidatorDecoratorInfo","pydantic._internal._decorators.FieldSerializerDecoratorInfo","pydantic._internal._decorators.ModelSerializerDecoratorInfo","pydantic._internal._decorators.ModelValidatorDecoratorInfo","pydantic.fields.ComputedFieldInfo"],"uses_pep604_syntax":false},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_staticmethod","is_ready","is_inferred"],"fullname":"pydantic._internal._decorators.Decorator.build","name":"build","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,3,3,3],"arg_names":["cls_","cls_var_name","shim","info"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"builtins.str",{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.DecoratorInfoType","id":1,"name":"DecoratorInfoType","namespace":"pydantic._internal._decorators.Decorator","upper_bound":{".class":"UnionType","items":["pydantic._internal._decorators.ValidatorDecoratorInfo","pydantic._internal._decorators.FieldValidatorDecoratorInfo","pydantic._internal._decorators.RootValidatorDecoratorInfo","pydantic._internal._decorators.FieldSerializerDecoratorInfo","pydantic._internal._decorators.ModelSerializerDecoratorInfo","pydantic._internal._decorators.ModelValidatorDecoratorInfo","pydantic.fields.ComputedFieldInfo"],"uses_pep604_syntax":false},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"build of Decorator","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.DecoratorInfoType","id":1,"name":"DecoratorInfoType","namespace":"pydantic._internal._decorators.Decorator","upper_bound":{".class":"UnionType","items":["pydantic._internal._decorators.ValidatorDecoratorInfo","pydantic._internal._decorators.FieldValidatorDecoratorInfo","pydantic._internal._decorators.RootValidatorDecoratorInfo","pydantic._internal._decorators.FieldSerializerDecoratorInfo","pydantic._internal._decorators.ModelSerializerDecoratorInfo","pydantic._internal._decorators.ModelValidatorDecoratorInfo","pydantic.fields.ComputedFieldInfo"],"uses_pep604_syntax":false},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"cls_ref":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._decorators.Decorator.cls_ref","name":"cls_ref","setter_type":null,"type":"builtins.str"}},"cls_var_name":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._decorators.Decorator.cls_var_name","name":"cls_var_name","setter_type":null,"type":"builtins.str"}},"func":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_settable_property","is_ready"],"fullname":"pydantic._internal._decorators.Decorator.func","name":"func","setter_type":null,"type":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"info":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._decorators.Decorator.info","name":"info","setter_type":null,"type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.DecoratorInfoType","id":1,"name":"DecoratorInfoType","namespace":"pydantic._internal._decorators.Decorator","upper_bound":{".class":"UnionType","items":["pydantic._internal._decorators.ValidatorDecoratorInfo","pydantic._internal._decorators.FieldValidatorDecoratorInfo","pydantic._internal._decorators.RootValidatorDecoratorInfo","pydantic._internal._decorators.FieldSerializerDecoratorInfo","pydantic._internal._decorators.ModelSerializerDecoratorInfo","pydantic._internal._decorators.ModelValidatorDecoratorInfo","pydantic.fields.ComputedFieldInfo"],"uses_pep604_syntax":false},"values":[],"variance":0}}},"shim":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._decorators.Decorator.shim","name":"shim","setter_type":null,"type":{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":true}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.Decorator.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.DecoratorInfoType","id":1,"name":"DecoratorInfoType","namespace":"pydantic._internal._decorators.Decorator","upper_bound":{".class":"UnionType","items":["pydantic._internal._decorators.ValidatorDecoratorInfo","pydantic._internal._decorators.FieldValidatorDecoratorInfo","pydantic._internal._decorators.RootValidatorDecoratorInfo","pydantic._internal._decorators.FieldSerializerDecoratorInfo","pydantic._internal._decorators.ModelSerializerDecoratorInfo","pydantic._internal._decorators.ModelValidatorDecoratorInfo","pydantic.fields.ComputedFieldInfo"],"uses_pep604_syntax":false},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["DecoratorInfoType"],"typeddict_type":null}},"DecoratorInfo":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic._internal._decorators.DecoratorInfo","line":148,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["pydantic._internal._decorators.ValidatorDecoratorInfo","pydantic._internal._decorators.FieldValidatorDecoratorInfo","pydantic._internal._decorators.RootValidatorDecoratorInfo","pydantic._internal._decorators.FieldSerializerDecoratorInfo","pydantic._internal._decorators.ModelSerializerDecoratorInfo","pydantic._internal._decorators.ModelValidatorDecoratorInfo","pydantic.fields.ComputedFieldInfo"],"uses_pep604_syntax":false}}},"DecoratorInfoType":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.DecoratorInfoType","name":"DecoratorInfoType","upper_bound":{".class":"UnionType","items":["pydantic._internal._decorators.ValidatorDecoratorInfo","pydantic._internal._decorators.FieldValidatorDecoratorInfo","pydantic._internal._decorators.RootValidatorDecoratorInfo","pydantic._internal._decorators.FieldSerializerDecoratorInfo","pydantic._internal._decorators.ModelSerializerDecoratorInfo","pydantic._internal._decorators.ModelValidatorDecoratorInfo","pydantic.fields.ComputedFieldInfo"],"uses_pep604_syntax":false},"values":[],"variance":0}},"DecoratorInfos":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._decorators.DecoratorInfos","name":"DecoratorInfos","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators.DecoratorInfos","has_param_spec_type":false,"metaclass_type":null,"metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":422,"name":"validators","type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic._internal._decorators.ValidatorDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.dict"}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":423,"name":"field_validators","type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic._internal._decorators.FieldValidatorDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.dict"}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":424,"name":"root_validators","type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic._internal._decorators.RootValidatorDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.dict"}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":425,"name":"field_serializers","type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic._internal._decorators.FieldSerializerDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.dict"}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":426,"name":"model_serializers","type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic._internal._decorators.ModelSerializerDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.dict"}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":427,"name":"model_validators","type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic._internal._decorators.ModelValidatorDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.dict"}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":428,"name":"computed_fields","type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic.fields.ComputedFieldInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.dict"}}],"frozen":false},"dataclass_tag":{}},"module_name":"pydantic._internal._decorators","mro":["pydantic._internal._decorators.DecoratorInfos","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"pydantic._internal._decorators.DecoratorInfos.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"dataclasses.Field"}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1,1],"arg_names":["self","validators","field_validators","root_validators","field_serializers","model_serializers","model_validators","computed_fields"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators.DecoratorInfos.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,1],"arg_names":["self","validators","field_validators","root_validators","field_serializers","model_serializers","model_validators","computed_fields"],"arg_types":["pydantic._internal._decorators.DecoratorInfos",{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic._internal._decorators.ValidatorDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic._internal._decorators.FieldValidatorDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic._internal._decorators.RootValidatorDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic._internal._decorators.FieldSerializerDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic._internal._decorators.ModelSerializerDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic._internal._decorators.ModelValidatorDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic.fields.ComputedFieldInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of DecoratorInfos","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5,5],"arg_names":["validators","field_validators","root_validators","field_serializers","model_serializers","model_validators","computed_fields"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"pydantic._internal._decorators.DecoratorInfos.__mypy-replace","name":"__mypy-replace","original_first_arg":"validators","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5],"arg_names":["validators","field_validators","root_validators","field_serializers","model_serializers","model_validators","computed_fields"],"arg_types":[{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic._internal._decorators.ValidatorDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic._internal._decorators.FieldValidatorDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic._internal._decorators.RootValidatorDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic._internal._decorators.FieldSerializerDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic._internal._decorators.ModelSerializerDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic._internal._decorators.ModelValidatorDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic.fields.ComputedFieldInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of DecoratorInfos","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"pydantic._internal._decorators.DecoratorInfos.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5],"arg_names":["validators","field_validators","root_validators","field_serializers","model_serializers","model_validators","computed_fields"],"arg_types":[{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic._internal._decorators.ValidatorDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic._internal._decorators.FieldValidatorDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic._internal._decorators.RootValidatorDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic._internal._decorators.FieldSerializerDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic._internal._decorators.ModelSerializerDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic._internal._decorators.ModelValidatorDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic.fields.ComputedFieldInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of DecoratorInfos","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"build":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["model_dc"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"pydantic._internal._decorators.DecoratorInfos.build","name":"build","original_first_arg":"model_dc","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["model_dc"],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"build of DecoratorInfos","ret_type":"pydantic._internal._decorators.DecoratorInfos","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_staticmethod","is_ready","is_inferred"],"fullname":"pydantic._internal._decorators.DecoratorInfos.build","name":"build","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["model_dc"],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"build of DecoratorInfos","ret_type":"pydantic._internal._decorators.DecoratorInfos","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"computed_fields":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic._internal._decorators.DecoratorInfos.computed_fields","name":"computed_fields","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic.fields.ComputedFieldInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"field_serializers":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic._internal._decorators.DecoratorInfos.field_serializers","name":"field_serializers","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic._internal._decorators.FieldSerializerDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"field_validators":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic._internal._decorators.DecoratorInfos.field_validators","name":"field_validators","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic._internal._decorators.FieldValidatorDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"model_serializers":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic._internal._decorators.DecoratorInfos.model_serializers","name":"model_serializers","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic._internal._decorators.ModelSerializerDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"model_validators":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic._internal._decorators.DecoratorInfos.model_validators","name":"model_validators","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic._internal._decorators.ModelValidatorDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"root_validators":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic._internal._decorators.DecoratorInfos.root_validators","name":"root_validators","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic._internal._decorators.RootValidatorDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"update_from_config":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","config_wrapper"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._decorators.DecoratorInfos.update_from_config","name":"update_from_config","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","config_wrapper"],"arg_types":["pydantic._internal._decorators.DecoratorInfos","pydantic._internal._config.ConfigWrapper"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"update_from_config of DecoratorInfos","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"validators":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic._internal._decorators.DecoratorInfos.validators","name":"validators","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic._internal._decorators.ValidatorDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.dict"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.DecoratorInfos.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._decorators.DecoratorInfos","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"FieldSerializerDecoratorInfo":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._decorators.FieldSerializerDecoratorInfo","name":"FieldSerializerDecoratorInfo","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators.FieldSerializerDecoratorInfo","has_param_spec_type":false,"metaclass_type":null,"metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":108,"name":"fields","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":109,"name":"mode","type":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"plain"},{".class":"LiteralType","fallback":"builtins.str","value":"wrap"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":110,"name":"return_type","type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":111,"name":"when_used","type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.WhenUsed"}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":112,"name":"check_fields","type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}}],"frozen":false},"dataclass_tag":{}},"module_name":"pydantic._internal._decorators","mro":["pydantic._internal._decorators.FieldSerializerDecoratorInfo","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"pydantic._internal._decorators.FieldSerializerDecoratorInfo.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"dataclasses.Field"}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0,0],"arg_names":["self","fields","mode","return_type","when_used","check_fields"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators.FieldSerializerDecoratorInfo.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0],"arg_names":["self","fields","mode","return_type","when_used","check_fields"],"arg_types":["pydantic._internal._decorators.FieldSerializerDecoratorInfo",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"plain"},{".class":"LiteralType","fallback":"builtins.str","value":"wrap"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.WhenUsed"},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of FieldSerializerDecoratorInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5],"arg_names":["fields","mode","return_type","when_used","check_fields"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"pydantic._internal._decorators.FieldSerializerDecoratorInfo.__mypy-replace","name":"__mypy-replace","original_first_arg":"fields","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5],"arg_names":["fields","mode","return_type","when_used","check_fields"],"arg_types":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"plain"},{".class":"LiteralType","fallback":"builtins.str","value":"wrap"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.WhenUsed"},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of FieldSerializerDecoratorInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"pydantic._internal._decorators.FieldSerializerDecoratorInfo.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5],"arg_names":["fields","mode","return_type","when_used","check_fields"],"arg_types":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"plain"},{".class":"LiteralType","fallback":"builtins.str","value":"wrap"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.WhenUsed"},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of FieldSerializerDecoratorInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"check_fields":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._decorators.FieldSerializerDecoratorInfo.check_fields","name":"check_fields","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"decorator_repr":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready","has_explicit_value"],"fullname":"pydantic._internal._decorators.FieldSerializerDecoratorInfo.decorator_repr","name":"decorator_repr","setter_type":null,"type":"builtins.str"}},"fields":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._decorators.FieldSerializerDecoratorInfo.fields","name":"fields","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}}},"mode":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._decorators.FieldSerializerDecoratorInfo.mode","name":"mode","setter_type":null,"type":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"plain"},{".class":"LiteralType","fallback":"builtins.str","value":"wrap"}],"uses_pep604_syntax":false}}},"return_type":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._decorators.FieldSerializerDecoratorInfo.return_type","name":"return_type","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"when_used":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._decorators.FieldSerializerDecoratorInfo.when_used","name":"when_used","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.WhenUsed"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.FieldSerializerDecoratorInfo.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._decorators.FieldSerializerDecoratorInfo","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"FieldValidatorDecoratorInfo":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._decorators.FieldValidatorDecoratorInfo","name":"FieldValidatorDecoratorInfo","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators.FieldValidatorDecoratorInfo","has_param_spec_type":false,"metaclass_type":null,"metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":72,"name":"fields","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":73,"name":"mode","type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.functional_validators.FieldValidatorModes"}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":74,"name":"check_fields","type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":75,"name":"json_schema_input_type","type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"frozen":false},"dataclass_tag":{}},"module_name":"pydantic._internal._decorators","mro":["pydantic._internal._decorators.FieldValidatorDecoratorInfo","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"pydantic._internal._decorators.FieldValidatorDecoratorInfo.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"dataclasses.Field"}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0],"arg_names":["self","fields","mode","check_fields","json_schema_input_type"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators.FieldValidatorDecoratorInfo.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":["self","fields","mode","check_fields","json_schema_input_type"],"arg_types":["pydantic._internal._decorators.FieldValidatorDecoratorInfo",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.functional_validators.FieldValidatorModes"},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of FieldValidatorDecoratorInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5],"arg_names":["fields","mode","check_fields","json_schema_input_type"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"pydantic._internal._decorators.FieldValidatorDecoratorInfo.__mypy-replace","name":"__mypy-replace","original_first_arg":"fields","type":{".class":"CallableType","arg_kinds":[5,5,5,5],"arg_names":["fields","mode","check_fields","json_schema_input_type"],"arg_types":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.functional_validators.FieldValidatorModes"},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of FieldValidatorDecoratorInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"pydantic._internal._decorators.FieldValidatorDecoratorInfo.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5],"arg_names":["fields","mode","check_fields","json_schema_input_type"],"arg_types":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.functional_validators.FieldValidatorModes"},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of FieldValidatorDecoratorInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"check_fields":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._decorators.FieldValidatorDecoratorInfo.check_fields","name":"check_fields","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"decorator_repr":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready","has_explicit_value"],"fullname":"pydantic._internal._decorators.FieldValidatorDecoratorInfo.decorator_repr","name":"decorator_repr","setter_type":null,"type":"builtins.str"}},"fields":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._decorators.FieldValidatorDecoratorInfo.fields","name":"fields","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}}},"json_schema_input_type":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._decorators.FieldValidatorDecoratorInfo.json_schema_input_type","name":"json_schema_input_type","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"mode":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._decorators.FieldValidatorDecoratorInfo.mode","name":"mode","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.functional_validators.FieldValidatorModes"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.FieldValidatorDecoratorInfo.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._decorators.FieldValidatorDecoratorInfo","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"FieldValidatorModes":{".class":"SymbolTableNode","cross_ref":"pydantic.functional_validators.FieldValidatorModes","kind":"Gdef"},"Generic":{".class":"SymbolTableNode","cross_ref":"typing.Generic","kind":"Gdef"},"GlobalsNamespace":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._namespace_utils.GlobalsNamespace","kind":"Gdef"},"Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"MappingNamespace":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._namespace_utils.MappingNamespace","kind":"Gdef"},"ModelSerializerDecoratorInfo":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._decorators.ModelSerializerDecoratorInfo","name":"ModelSerializerDecoratorInfo","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators.ModelSerializerDecoratorInfo","has_param_spec_type":false,"metaclass_type":null,"metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":129,"name":"mode","type":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"plain"},{".class":"LiteralType","fallback":"builtins.str","value":"wrap"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":130,"name":"return_type","type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":131,"name":"when_used","type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.WhenUsed"}}],"frozen":false},"dataclass_tag":{}},"module_name":"pydantic._internal._decorators","mro":["pydantic._internal._decorators.ModelSerializerDecoratorInfo","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"pydantic._internal._decorators.ModelSerializerDecoratorInfo.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"dataclasses.Field"}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","mode","return_type","when_used"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators.ModelSerializerDecoratorInfo.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","mode","return_type","when_used"],"arg_types":["pydantic._internal._decorators.ModelSerializerDecoratorInfo",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"plain"},{".class":"LiteralType","fallback":"builtins.str","value":"wrap"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.WhenUsed"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of ModelSerializerDecoratorInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5],"arg_names":["mode","return_type","when_used"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"pydantic._internal._decorators.ModelSerializerDecoratorInfo.__mypy-replace","name":"__mypy-replace","original_first_arg":"mode","type":{".class":"CallableType","arg_kinds":[5,5,5],"arg_names":["mode","return_type","when_used"],"arg_types":[{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"plain"},{".class":"LiteralType","fallback":"builtins.str","value":"wrap"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.WhenUsed"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of ModelSerializerDecoratorInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"pydantic._internal._decorators.ModelSerializerDecoratorInfo.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5],"arg_names":["mode","return_type","when_used"],"arg_types":[{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"plain"},{".class":"LiteralType","fallback":"builtins.str","value":"wrap"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.WhenUsed"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of ModelSerializerDecoratorInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"decorator_repr":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready","has_explicit_value"],"fullname":"pydantic._internal._decorators.ModelSerializerDecoratorInfo.decorator_repr","name":"decorator_repr","setter_type":null,"type":"builtins.str"}},"mode":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._decorators.ModelSerializerDecoratorInfo.mode","name":"mode","setter_type":null,"type":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"plain"},{".class":"LiteralType","fallback":"builtins.str","value":"wrap"}],"uses_pep604_syntax":false}}},"return_type":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._decorators.ModelSerializerDecoratorInfo.return_type","name":"return_type","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"when_used":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._decorators.ModelSerializerDecoratorInfo.when_used","name":"when_used","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.WhenUsed"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.ModelSerializerDecoratorInfo.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._decorators.ModelSerializerDecoratorInfo","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ModelValidatorDecoratorInfo":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._decorators.ModelValidatorDecoratorInfo","name":"ModelValidatorDecoratorInfo","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators.ModelValidatorDecoratorInfo","has_param_spec_type":false,"metaclass_type":null,"metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":145,"name":"mode","type":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"wrap"},{".class":"LiteralType","fallback":"builtins.str","value":"before"},{".class":"LiteralType","fallback":"builtins.str","value":"after"}],"uses_pep604_syntax":false}}],"frozen":false},"dataclass_tag":{}},"module_name":"pydantic._internal._decorators","mro":["pydantic._internal._decorators.ModelValidatorDecoratorInfo","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"pydantic._internal._decorators.ModelValidatorDecoratorInfo.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"dataclasses.Field"}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators.ModelValidatorDecoratorInfo.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","mode"],"arg_types":["pydantic._internal._decorators.ModelValidatorDecoratorInfo",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"wrap"},{".class":"LiteralType","fallback":"builtins.str","value":"before"},{".class":"LiteralType","fallback":"builtins.str","value":"after"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of ModelValidatorDecoratorInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5],"arg_names":["mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"pydantic._internal._decorators.ModelValidatorDecoratorInfo.__mypy-replace","name":"__mypy-replace","original_first_arg":"mode","type":{".class":"CallableType","arg_kinds":[5],"arg_names":["mode"],"arg_types":[{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"wrap"},{".class":"LiteralType","fallback":"builtins.str","value":"before"},{".class":"LiteralType","fallback":"builtins.str","value":"after"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of ModelValidatorDecoratorInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"pydantic._internal._decorators.ModelValidatorDecoratorInfo.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5],"arg_names":["mode"],"arg_types":[{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"wrap"},{".class":"LiteralType","fallback":"builtins.str","value":"before"},{".class":"LiteralType","fallback":"builtins.str","value":"after"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of ModelValidatorDecoratorInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"decorator_repr":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready","has_explicit_value"],"fullname":"pydantic._internal._decorators.ModelValidatorDecoratorInfo.decorator_repr","name":"decorator_repr","setter_type":null,"type":"builtins.str"}},"mode":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._decorators.ModelValidatorDecoratorInfo.mode","name":"mode","setter_type":null,"type":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"wrap"},{".class":"LiteralType","fallback":"builtins.str","value":"before"},{".class":"LiteralType","fallback":"builtins.str","value":"after"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.ModelValidatorDecoratorInfo.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._decorators.ModelValidatorDecoratorInfo","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Parameter":{".class":"SymbolTableNode","cross_ref":"inspect.Parameter","kind":"Gdef"},"PydanticDescriptorProxy":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._decorators.PydanticDescriptorProxy","name":"PydanticDescriptorProxy","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.ReturnType","id":1,"name":"ReturnType","namespace":"pydantic._internal._decorators.PydanticDescriptorProxy","upper_bound":"builtins.object","values":[],"variance":0}]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators.PydanticDescriptorProxy","has_param_spec_type":false,"metaclass_type":null,"metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":179,"name":"wrapped","type":{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.ReturnType","id":1,"name":"ReturnType","namespace":"pydantic._internal._decorators.PydanticDescriptorProxy","upper_bound":"builtins.object","values":[],"variance":0}],"type_ref":"pydantic._internal._decorators.DecoratedType"}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":180,"name":"decorator_info","type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._decorators.DecoratorInfo"}},{"alias":null,"column":4,"has_default":true,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":181,"name":"shim","type":{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":true}}],"frozen":false},"dataclass_tag":{}},"module_name":"pydantic._internal._decorators","mro":["pydantic._internal._decorators.PydanticDescriptorProxy","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"pydantic._internal._decorators.PydanticDescriptorProxy.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"dataclasses.Field"}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__get__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","obj","obj_type"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._decorators.PydanticDescriptorProxy.__get__","name":"__get__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","obj","obj_type"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.ReturnType","id":1,"name":"ReturnType","namespace":"pydantic._internal._decorators.PydanticDescriptorProxy","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.PydanticDescriptorProxy"},{".class":"UnionType","items":["builtins.object",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeType","item":"builtins.object"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get__ of PydanticDescriptorProxy","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.ReturnType","id":1,"name":"ReturnType","namespace":"pydantic._internal._decorators.PydanticDescriptorProxy","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.PydanticDescriptorProxy"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__getattr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._decorators.PydanticDescriptorProxy.__getattr__","name":"__getattr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.ReturnType","id":1,"name":"ReturnType","namespace":"pydantic._internal._decorators.PydanticDescriptorProxy","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.PydanticDescriptorProxy"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getattr__ of PydanticDescriptorProxy","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","wrapped","decorator_info","shim"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators.PydanticDescriptorProxy.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","wrapped","decorator_info","shim"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.ReturnType","id":1,"name":"ReturnType","namespace":"pydantic._internal._decorators.PydanticDescriptorProxy","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.PydanticDescriptorProxy"},{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.ReturnType","id":1,"name":"ReturnType","namespace":"pydantic._internal._decorators.PydanticDescriptorProxy","upper_bound":"builtins.object","values":[],"variance":0}],"type_ref":"pydantic._internal._decorators.DecoratedType"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._decorators.DecoratorInfo"},{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of PydanticDescriptorProxy","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-post_init":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators.PydanticDescriptorProxy.__mypy-post_init","name":"__mypy-post_init","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.ReturnType","id":1,"name":"ReturnType","namespace":"pydantic._internal._decorators.PydanticDescriptorProxy","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.PydanticDescriptorProxy"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-post_init of PydanticDescriptorProxy","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5],"arg_names":["wrapped","decorator_info","shim"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"pydantic._internal._decorators.PydanticDescriptorProxy.__mypy-replace","name":"__mypy-replace","original_first_arg":"wrapped","type":{".class":"CallableType","arg_kinds":[5,5,5],"arg_names":["wrapped","decorator_info","shim"],"arg_types":[{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.ReturnType","id":1,"name":"ReturnType","namespace":"pydantic._internal._decorators.PydanticDescriptorProxy","upper_bound":"builtins.object","values":[],"variance":0}],"type_ref":"pydantic._internal._decorators.DecoratedType"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._decorators.DecoratorInfo"},{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of PydanticDescriptorProxy","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"pydantic._internal._decorators.PydanticDescriptorProxy.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5],"arg_names":["wrapped","decorator_info","shim"],"arg_types":[{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.ReturnType","id":1,"name":"ReturnType","namespace":"pydantic._internal._decorators.PydanticDescriptorProxy","upper_bound":"builtins.object","values":[],"variance":0}],"type_ref":"pydantic._internal._decorators.DecoratedType"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._decorators.DecoratorInfo"},{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of PydanticDescriptorProxy","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"__post_init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators.PydanticDescriptorProxy.__post_init__","name":"__post_init__","original_first_arg":"self","type":null}},"__set_name__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","instance","name"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._decorators.PydanticDescriptorProxy.__set_name__","name":"__set_name__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","instance","name"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.ReturnType","id":1,"name":"ReturnType","namespace":"pydantic._internal._decorators.PydanticDescriptorProxy","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.PydanticDescriptorProxy"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__set_name__ of PydanticDescriptorProxy","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_call_wrapped_attr":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,3],"arg_names":["self","func","name"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._decorators.PydanticDescriptorProxy._call_wrapped_attr","name":"_call_wrapped_attr","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,3],"arg_names":["self","func","name"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.ReturnType","id":1,"name":"ReturnType","namespace":"pydantic._internal._decorators.PydanticDescriptorProxy","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.PydanticDescriptorProxy"},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_call_wrapped_attr of PydanticDescriptorProxy","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.ReturnType","id":1,"name":"ReturnType","namespace":"pydantic._internal._decorators.PydanticDescriptorProxy","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.PydanticDescriptorProxy"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"decorator_info":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._decorators.PydanticDescriptorProxy.decorator_info","name":"decorator_info","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._decorators.DecoratorInfo"}}},"shim":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic._internal._decorators.PydanticDescriptorProxy.shim","name":"shim","setter_type":null,"type":{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":true}}},"wrapped":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._decorators.PydanticDescriptorProxy.wrapped","name":"wrapped","setter_type":null,"type":{".class":"TypeAliasType","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.ReturnType","id":1,"name":"ReturnType","namespace":"pydantic._internal._decorators.PydanticDescriptorProxy","upper_bound":"builtins.object","values":[],"variance":0}],"type_ref":"pydantic._internal._decorators.DecoratedType"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.PydanticDescriptorProxy.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.ReturnType","id":1,"name":"ReturnType","namespace":"pydantic._internal._decorators.PydanticDescriptorProxy","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.PydanticDescriptorProxy"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["ReturnType"],"typeddict_type":null}},"PydanticUndefined":{".class":"SymbolTableNode","cross_ref":"pydantic_core._pydantic_core.PydanticUndefined","kind":"Gdef"},"PydanticUndefinedType":{".class":"SymbolTableNode","cross_ref":"pydantic_core._pydantic_core.PydanticUndefinedType","kind":"Gdef"},"PydanticUserError":{".class":"SymbolTableNode","cross_ref":"pydantic.errors.PydanticUserError","kind":"Gdef"},"ReturnType":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.ReturnType","name":"ReturnType","upper_bound":"builtins.object","values":[],"variance":0}},"RootValidatorDecoratorInfo":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._decorators.RootValidatorDecoratorInfo","name":"RootValidatorDecoratorInfo","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators.RootValidatorDecoratorInfo","has_param_spec_type":false,"metaclass_type":null,"metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":89,"name":"mode","type":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"before"},{".class":"LiteralType","fallback":"builtins.str","value":"after"}],"uses_pep604_syntax":false}}],"frozen":false},"dataclass_tag":{}},"module_name":"pydantic._internal._decorators","mro":["pydantic._internal._decorators.RootValidatorDecoratorInfo","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"pydantic._internal._decorators.RootValidatorDecoratorInfo.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"dataclasses.Field"}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators.RootValidatorDecoratorInfo.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","mode"],"arg_types":["pydantic._internal._decorators.RootValidatorDecoratorInfo",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"before"},{".class":"LiteralType","fallback":"builtins.str","value":"after"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of RootValidatorDecoratorInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5],"arg_names":["mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"pydantic._internal._decorators.RootValidatorDecoratorInfo.__mypy-replace","name":"__mypy-replace","original_first_arg":"mode","type":{".class":"CallableType","arg_kinds":[5],"arg_names":["mode"],"arg_types":[{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"before"},{".class":"LiteralType","fallback":"builtins.str","value":"after"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of RootValidatorDecoratorInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"pydantic._internal._decorators.RootValidatorDecoratorInfo.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5],"arg_names":["mode"],"arg_types":[{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"before"},{".class":"LiteralType","fallback":"builtins.str","value":"after"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of RootValidatorDecoratorInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"decorator_repr":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready","has_explicit_value"],"fullname":"pydantic._internal._decorators.RootValidatorDecoratorInfo.decorator_repr","name":"decorator_repr","setter_type":null,"type":"builtins.str"}},"mode":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._decorators.RootValidatorDecoratorInfo.mode","name":"mode","setter_type":null,"type":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"before"},{".class":"LiteralType","fallback":"builtins.str","value":"after"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.RootValidatorDecoratorInfo.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._decorators.RootValidatorDecoratorInfo","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Signature":{".class":"SymbolTableNode","cross_ref":"inspect.Signature","kind":"Gdef"},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"TypeAlias":{".class":"SymbolTableNode","cross_ref":"typing_extensions.TypeAlias","kind":"Gdef"},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"ValidatorDecoratorInfo":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._decorators.ValidatorDecoratorInfo","name":"ValidatorDecoratorInfo","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators.ValidatorDecoratorInfo","has_param_spec_type":false,"metaclass_type":null,"metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":48,"name":"fields","type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":49,"name":"mode","type":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"before"},{".class":"LiteralType","fallback":"builtins.str","value":"after"}],"uses_pep604_syntax":false}},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":50,"name":"each_item","type":"builtins.bool"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":51,"name":"always","type":"builtins.bool"},{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":52,"name":"check_fields","type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}}],"frozen":false},"dataclass_tag":{}},"module_name":"pydantic._internal._decorators","mro":["pydantic._internal._decorators.ValidatorDecoratorInfo","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"pydantic._internal._decorators.ValidatorDecoratorInfo.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"dataclasses.Field"}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0,0],"arg_names":["self","fields","mode","each_item","always","check_fields"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators.ValidatorDecoratorInfo.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0],"arg_names":["self","fields","mode","each_item","always","check_fields"],"arg_types":["pydantic._internal._decorators.ValidatorDecoratorInfo",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"before"},{".class":"LiteralType","fallback":"builtins.str","value":"after"}],"uses_pep604_syntax":false},"builtins.bool","builtins.bool",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of ValidatorDecoratorInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5],"arg_names":["fields","mode","each_item","always","check_fields"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"pydantic._internal._decorators.ValidatorDecoratorInfo.__mypy-replace","name":"__mypy-replace","original_first_arg":"fields","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5],"arg_names":["fields","mode","each_item","always","check_fields"],"arg_types":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"before"},{".class":"LiteralType","fallback":"builtins.str","value":"after"}],"uses_pep604_syntax":false},"builtins.bool","builtins.bool",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of ValidatorDecoratorInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"pydantic._internal._decorators.ValidatorDecoratorInfo.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5],"arg_names":["fields","mode","each_item","always","check_fields"],"arg_types":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"before"},{".class":"LiteralType","fallback":"builtins.str","value":"after"}],"uses_pep604_syntax":false},"builtins.bool","builtins.bool",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of ValidatorDecoratorInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"always":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._decorators.ValidatorDecoratorInfo.always","name":"always","setter_type":null,"type":"builtins.bool"}},"check_fields":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._decorators.ValidatorDecoratorInfo.check_fields","name":"check_fields","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"decorator_repr":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready","has_explicit_value"],"fullname":"pydantic._internal._decorators.ValidatorDecoratorInfo.decorator_repr","name":"decorator_repr","setter_type":null,"type":"builtins.str"}},"each_item":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._decorators.ValidatorDecoratorInfo.each_item","name":"each_item","setter_type":null,"type":"builtins.bool"}},"fields":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._decorators.ValidatorDecoratorInfo.fields","name":"fields","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}}},"mode":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._decorators.ValidatorDecoratorInfo.mode","name":"mode","setter_type":null,"type":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"before"},{".class":"LiteralType","fallback":"builtins.str","value":"after"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators.ValidatorDecoratorInfo.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._decorators.ValidatorDecoratorInfo","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._decorators.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._decorators.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._decorators.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._decorators.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._decorators.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._decorators.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"_function_like":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._decorators._function_like","name":"_function_like","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":[{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":[null,"args","kwargs"],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"functools._T","id":1,"name":"_T","namespace":"functools.partial","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.type","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":"partial","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"functools._T","id":1,"name":"_T","namespace":"functools.partial","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"functools.partial"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"functools._T","id":1,"name":"_T","namespace":"functools.partial","upper_bound":"builtins.object","values":[],"variance":0}]},{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":[null,"args","keywords"],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"functools._T","id":1,"name":"_T","namespace":"functools.partialmethod","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.type","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":"partialmethod","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"functools._T","id":1,"name":"_T","namespace":"functools.partialmethod","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"functools.partialmethod"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"functools._T","id":1,"name":"_T","namespace":"functools.partialmethod","upper_bound":"builtins.object","values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":[null,"args","keywords"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"functools._Descriptor"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.type","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":"partialmethod","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"functools._T","id":1,"name":"_T","namespace":"functools.partialmethod","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"functools.partialmethod"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"functools._T","id":1,"name":"_T","namespace":"functools.partialmethod","upper_bound":"builtins.object","values":[],"variance":0}]}]},{".class":"CallableType","arg_kinds":[0,0,1,1,1],"arg_names":["code","globals","name","argdefs","closure"],"arg_types":["types.CodeType",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.object"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["types.CellType"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.type","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":"FunctionType","ret_type":"types.FunctionType","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.type","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":"BuiltinFunctionType","ret_type":"types.BuiltinFunctionType","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"builtins.object"],"fallback":"builtins.type","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":"MethodType","ret_type":"types.MethodType","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.type","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":"WrapperDescriptorType","ret_type":"types.WrapperDescriptorType","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.type","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":"MethodWrapperType","ret_type":"types.MethodWrapperType","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.type","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":"MemberDescriptorType","ret_type":"types.MemberDescriptorType","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_is_classmethod_from_sig":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["function"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators._is_classmethod_from_sig","name":"_is_classmethod_from_sig","original_first_arg":"function","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["function"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._decorators.AnyDecoratorCallable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_is_classmethod_from_sig","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_sentinel":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._decorators._sentinel","name":"_sentinel","setter_type":null,"type":"builtins.object"}},"_serializer_info_arg":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["mode","n_positional"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators._serializer_info_arg","name":"_serializer_info_arg","original_first_arg":"mode","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["mode","n_positional"],"arg_types":[{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"plain"},{".class":"LiteralType","fallback":"builtins.str","value":"wrap"}],"uses_pep604_syntax":false},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_serializer_info_arg","ret_type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_signature_no_eval":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["f"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators._signature_no_eval","name":"_signature_no_eval","original_first_arg":"f","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["f"],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_signature_no_eval","ret_type":"inspect.Signature","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"cached_property":{".class":"SymbolTableNode","cross_ref":"functools.cached_property","kind":"Gdef"},"can_be_positional":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._utils.can_be_positional","kind":"Gdef"},"core_schema":{".class":"SymbolTableNode","cross_ref":"pydantic_core.core_schema","kind":"Gdef"},"count_positional_required_params":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["sig"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators.count_positional_required_params","name":"count_positional_required_params","original_first_arg":"sig","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["sig"],"arg_types":["inspect.Signature"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"count_positional_required_params","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"dataclass":{".class":"SymbolTableNode","cross_ref":"dataclasses.dataclass","kind":"Gdef"},"deque":{".class":"SymbolTableNode","cross_ref":"collections.deque","kind":"Gdef"},"ensure_classmethod_based_on_signature":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["function"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators.ensure_classmethod_based_on_signature","name":"ensure_classmethod_based_on_signature","original_first_arg":"function","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["function"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._decorators.AnyDecoratorCallable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ensure_classmethod_based_on_signature","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"ensure_property":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["f"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators.ensure_property","name":"ensure_property","original_first_arg":"f","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["f"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ensure_property","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"field":{".class":"SymbolTableNode","cross_ref":"dataclasses.field","kind":"Gdef"},"get_attribute_from_base_dicts":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["tp","name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators.get_attribute_from_base_dicts","name":"get_attribute_from_base_dicts","original_first_arg":"tp","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["tp","name"],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_attribute_from_base_dicts","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_attribute_from_bases":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["tp","name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators.get_attribute_from_bases","name":"get_attribute_from_bases","original_first_arg":"tp","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["tp","name"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},{".class":"Instance","args":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":true},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_attribute_from_bases","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_bases":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["tp"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators.get_bases","name":"get_bases","original_first_arg":"tp","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["tp"],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_bases","ret_type":{".class":"Instance","args":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_callable_return_type":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["callable_obj","globalns","localns"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators.get_callable_return_type","name":"get_callable_return_type","original_first_arg":"callable_obj","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["callable_obj","globalns","localns"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.GlobalsNamespace"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_callable_return_type","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"pydantic_core._pydantic_core.PydanticUndefinedType"],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_function_type_hints":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._typing_extra.get_function_type_hints","kind":"Gdef"},"get_type_ref":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._core_utils.get_type_ref","kind":"Gdef"},"inspect_annotated_serializer":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["serializer","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators.inspect_annotated_serializer","name":"inspect_annotated_serializer","original_first_arg":"serializer","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["serializer","mode"],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"plain"},{".class":"LiteralType","fallback":"builtins.str","value":"wrap"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"inspect_annotated_serializer","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"inspect_field_serializer":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["serializer","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators.inspect_field_serializer","name":"inspect_field_serializer","original_first_arg":"serializer","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["serializer","mode"],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"plain"},{".class":"LiteralType","fallback":"builtins.str","value":"wrap"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"inspect_field_serializer","ret_type":{".class":"TupleType","implicit":false,"items":["builtins.bool","builtins.bool"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"inspect_model_serializer":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["serializer","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators.inspect_model_serializer","name":"inspect_model_serializer","original_first_arg":"serializer","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["serializer","mode"],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"plain"},{".class":"LiteralType","fallback":"builtins.str","value":"wrap"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"inspect_model_serializer","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"inspect_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,3],"arg_names":["validator","mode","type"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators.inspect_validator","name":"inspect_validator","original_first_arg":"validator","type":{".class":"CallableType","arg_kinds":[0,3,3],"arg_names":["validator","mode","type"],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.functional_validators.FieldValidatorModes"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"field"},{".class":"LiteralType","fallback":"builtins.str","value":"model"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"inspect_validator","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_instance_method_from_sig":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["function"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators.is_instance_method_from_sig","name":"is_instance_method_from_sig","original_first_arg":"function","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["function"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._decorators.AnyDecoratorCallable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_instance_method_from_sig","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_typeddict":{".class":"SymbolTableNode","cross_ref":"typing_extensions.is_typeddict","kind":"Gdef"},"isdatadescriptor":{".class":"SymbolTableNode","cross_ref":"inspect.isdatadescriptor","kind":"Gdef"},"islice":{".class":"SymbolTableNode","cross_ref":"itertools.islice","kind":"Gdef"},"ismethoddescriptor":{".class":"SymbolTableNode","cross_ref":"inspect.ismethoddescriptor","kind":"Gdef"},"mro":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["tp"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators.mro","name":"mro","original_first_arg":"tp","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["tp"],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mro","ret_type":{".class":"Instance","args":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"mro_for_bases":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["bases"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators.mro_for_bases","name":"mro_for_bases","original_first_arg":"bases","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["bases"],"arg_types":[{".class":"Instance","args":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"mro_for_bases","ret_type":{".class":"Instance","args":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"partial":{".class":"SymbolTableNode","cross_ref":"functools.partial","kind":"Gdef"},"partialmethod":{".class":"SymbolTableNode","cross_ref":"functools.partialmethod","kind":"Gdef"},"signature":{".class":"SymbolTableNode","cross_ref":"inspect.signature","kind":"Gdef"},"slots_true":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._internal_dataclass.slots_true","kind":"Gdef"},"sys":{".class":"SymbolTableNode","cross_ref":"sys","kind":"Gdef"},"types":{".class":"SymbolTableNode","cross_ref":"types","kind":"Gdef"},"unwrap_wrapped_function":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5],"arg_names":["func","unwrap_partial","unwrap_class_static_method"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators.unwrap_wrapped_function","name":"unwrap_wrapped_function","original_first_arg":"func","type":{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":["func","unwrap_partial","unwrap_class_static_method"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unwrap_wrapped_function","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_decorators.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_decorators.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_decorators.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..ce68e9eef53dd3dfa9743cc4f63f60f5e7392775 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_decorators.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[19,20,21,22,23,28,8,15,18,26,27,3,5,6,7,9,10,11,12,13,15,16,1,1,1,1,1,1],"dep_prios":[5,5,5,5,5,25,5,10,5,20,25,5,10,10,5,5,5,5,5,5,5,5,5,30,30,30,30,30],"dependencies":["pydantic._internal._core_utils","pydantic._internal._internal_dataclass","pydantic._internal._namespace_utils","pydantic._internal._typing_extra","pydantic._internal._utils","pydantic._internal._config","collections.abc","pydantic_core.core_schema","pydantic.errors","pydantic.fields","pydantic.functional_validators","__future__","sys","types","collections","dataclasses","functools","inspect","itertools","typing","pydantic_core","typing_extensions","builtins","_frozen_importlib","_typeshed","abc","enum","pydantic_core._pydantic_core"],"hash":"a59e2c087ee26392efd2452fca7741c986fcb4fb","id":"pydantic._internal._decorators","ignore_all":true,"interface_hash":"c589a8fb10aa52c357ac8b27a08010b8fa0fb24d","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_decorators.py","plugin_data":null,"size":33529,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_decorators_v1.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_decorators_v1.data.json new file mode 100644 index 0000000000000000000000000000000000000000..5a31cb5b579c4976857c1ca88ee59582cd822c6d --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_decorators_v1.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic._internal._decorators_v1","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"Parameter":{".class":"SymbolTableNode","cross_ref":"inspect.Parameter","kind":"Gdef"},"Protocol":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Protocol","kind":"Gdef"},"PydanticUserError":{".class":"SymbolTableNode","cross_ref":"pydantic.errors.PydanticUserError","kind":"Gdef"},"RootValidatorFieldsTuple":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic._internal._decorators_v1.RootValidatorFieldsTuple","line":110,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}},"RootValidatorValues":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic._internal._decorators_v1.RootValidatorValues","line":108,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"V1OnlyValueValidator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[["__call__",2]],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._decorators_v1.V1OnlyValueValidator","name":"V1OnlyValueValidator","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_abstract","is_protocol"],"fullname":"pydantic._internal._decorators_v1.V1OnlyValueValidator","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic._internal._decorators_v1","mro":["pydantic._internal._decorators_v1.V1OnlyValueValidator","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0,0],"arg_names":["self",null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_body","is_trivial_self"],"fullname":"pydantic._internal._decorators_v1.V1OnlyValueValidator.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self",null],"arg_types":["pydantic._internal._decorators_v1.V1OnlyValueValidator",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of V1OnlyValueValidator","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators_v1.V1OnlyValueValidator.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._decorators_v1.V1OnlyValueValidator","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"V1RootValidatorFunction":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[["__call__",2]],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._decorators_v1.V1RootValidatorFunction","name":"V1RootValidatorFunction","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_abstract","is_protocol"],"fullname":"pydantic._internal._decorators_v1.V1RootValidatorFunction","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic._internal._decorators_v1","mro":["pydantic._internal._decorators_v1.V1RootValidatorFunction","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0,0],"arg_names":["self",null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_body","is_trivial_self"],"fullname":"pydantic._internal._decorators_v1.V1RootValidatorFunction.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self",null],"arg_types":["pydantic._internal._decorators_v1.V1RootValidatorFunction",{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._decorators_v1.RootValidatorValues"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of V1RootValidatorFunction","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._decorators_v1.RootValidatorValues"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators_v1.V1RootValidatorFunction.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._decorators_v1.V1RootValidatorFunction","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"V1Validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic._internal._decorators_v1.V1Validator","line":45,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["pydantic._internal._decorators_v1.V1ValidatorWithValues","pydantic._internal._decorators_v1.V1ValidatorWithValuesKwOnly","pydantic._internal._decorators_v1.V1ValidatorWithKwargs","pydantic._internal._decorators_v1.V1ValidatorWithValuesAndKwargs"],"uses_pep604_syntax":false}}},"V1ValidatorWithKwargs":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[["__call__",2]],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._decorators_v1.V1ValidatorWithKwargs","name":"V1ValidatorWithKwargs","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_abstract","is_protocol"],"fullname":"pydantic._internal._decorators_v1.V1ValidatorWithKwargs","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic._internal._decorators_v1","mro":["pydantic._internal._decorators_v1.V1ValidatorWithKwargs","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0,0,4],"arg_names":["self",null,"kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_body","is_trivial_self"],"fullname":"pydantic._internal._decorators_v1.V1ValidatorWithKwargs.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,4],"arg_names":["self",null,"kwargs"],"arg_types":["pydantic._internal._decorators_v1.V1ValidatorWithKwargs",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of V1ValidatorWithKwargs","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators_v1.V1ValidatorWithKwargs.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._decorators_v1.V1ValidatorWithKwargs","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"V1ValidatorWithValues":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[["__call__",2]],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._decorators_v1.V1ValidatorWithValues","name":"V1ValidatorWithValues","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_abstract","is_protocol"],"fullname":"pydantic._internal._decorators_v1.V1ValidatorWithValues","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic._internal._decorators_v1","mro":["pydantic._internal._decorators_v1.V1ValidatorWithValues","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0,0,0],"arg_names":["self",null,"values"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_body","is_trivial_self"],"fullname":"pydantic._internal._decorators_v1.V1ValidatorWithValues.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self",null,"values"],"arg_types":["pydantic._internal._decorators_v1.V1ValidatorWithValues",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of V1ValidatorWithValues","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators_v1.V1ValidatorWithValues.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._decorators_v1.V1ValidatorWithValues","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"V1ValidatorWithValuesAndKwargs":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[["__call__",2]],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._decorators_v1.V1ValidatorWithValuesAndKwargs","name":"V1ValidatorWithValuesAndKwargs","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_abstract","is_protocol"],"fullname":"pydantic._internal._decorators_v1.V1ValidatorWithValuesAndKwargs","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic._internal._decorators_v1","mro":["pydantic._internal._decorators_v1.V1ValidatorWithValuesAndKwargs","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0,0,0,4],"arg_names":["self",null,"values","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_body","is_trivial_self"],"fullname":"pydantic._internal._decorators_v1.V1ValidatorWithValuesAndKwargs.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,4],"arg_names":["self",null,"values","kwargs"],"arg_types":["pydantic._internal._decorators_v1.V1ValidatorWithValuesAndKwargs",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of V1ValidatorWithValuesAndKwargs","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators_v1.V1ValidatorWithValuesAndKwargs.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._decorators_v1.V1ValidatorWithValuesAndKwargs","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"V1ValidatorWithValuesKwOnly":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[["__call__",2]],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._decorators_v1.V1ValidatorWithValuesKwOnly","name":"V1ValidatorWithValuesKwOnly","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_abstract","is_protocol"],"fullname":"pydantic._internal._decorators_v1.V1ValidatorWithValuesKwOnly","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic._internal._decorators_v1","mro":["pydantic._internal._decorators_v1.V1ValidatorWithValuesKwOnly","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0,0,3],"arg_names":["self",null,"values"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_body","is_trivial_self"],"fullname":"pydantic._internal._decorators_v1.V1ValidatorWithValuesKwOnly.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,3],"arg_names":["self",null,"values"],"arg_types":["pydantic._internal._decorators_v1.V1ValidatorWithValuesKwOnly",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of V1ValidatorWithValuesKwOnly","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators_v1.V1ValidatorWithValuesKwOnly.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._decorators_v1.V1ValidatorWithValuesKwOnly","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"V2CoreAfterRootValidator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[["__call__",2]],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._decorators_v1.V2CoreAfterRootValidator","name":"V2CoreAfterRootValidator","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_abstract","is_protocol"],"fullname":"pydantic._internal._decorators_v1.V2CoreAfterRootValidator","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic._internal._decorators_v1","mro":["pydantic._internal._decorators_v1.V2CoreAfterRootValidator","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0,0,0],"arg_names":["self",null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_body","is_trivial_self"],"fullname":"pydantic._internal._decorators_v1.V2CoreAfterRootValidator.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self",null,null],"arg_types":["pydantic._internal._decorators_v1.V2CoreAfterRootValidator",{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._decorators_v1.RootValidatorFieldsTuple"},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"pydantic_core.core_schema.ValidationInfo"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of V2CoreAfterRootValidator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._decorators_v1.RootValidatorFieldsTuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators_v1.V2CoreAfterRootValidator.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._decorators_v1.V2CoreAfterRootValidator","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"V2CoreBeforeRootValidator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[["__call__",2]],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._decorators_v1.V2CoreBeforeRootValidator","name":"V2CoreBeforeRootValidator","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_abstract","is_protocol"],"fullname":"pydantic._internal._decorators_v1.V2CoreBeforeRootValidator","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic._internal._decorators_v1","mro":["pydantic._internal._decorators_v1.V2CoreBeforeRootValidator","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0,0,0],"arg_names":["self",null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_body","is_trivial_self"],"fullname":"pydantic._internal._decorators_v1.V2CoreBeforeRootValidator.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self",null,null],"arg_types":["pydantic._internal._decorators_v1.V2CoreBeforeRootValidator",{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._decorators_v1.RootValidatorValues"},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"pydantic_core.core_schema.ValidationInfo"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of V2CoreBeforeRootValidator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._decorators_v1.RootValidatorValues"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._decorators_v1.V2CoreBeforeRootValidator.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._decorators_v1.V2CoreBeforeRootValidator","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._decorators_v1.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._decorators_v1.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._decorators_v1.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._decorators_v1.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._decorators_v1.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._decorators_v1.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"can_be_keyword":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["param"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators_v1.can_be_keyword","name":"can_be_keyword","original_first_arg":"param","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["param"],"arg_types":["inspect.Parameter"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"can_be_keyword","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"can_be_positional":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._utils.can_be_positional","kind":"Gdef"},"cast":{".class":"SymbolTableNode","cross_ref":"typing.cast","kind":"Gdef"},"core_schema":{".class":"SymbolTableNode","cross_ref":"pydantic_core.core_schema","kind":"Gdef"},"make_generic_v1_field_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["validator"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators_v1.make_generic_v1_field_validator","name":"make_generic_v1_field_validator","original_first_arg":"validator","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["validator"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._decorators_v1.V1Validator"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"make_generic_v1_field_validator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.WithInfoValidatorFunction"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"make_v1_generic_root_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["validator","pre"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._decorators_v1.make_v1_generic_root_validator","name":"make_v1_generic_root_validator","original_first_arg":"validator","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["validator","pre"],"arg_types":["pydantic._internal._decorators_v1.V1RootValidatorFunction","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"make_v1_generic_root_validator","ret_type":{".class":"UnionType","items":["pydantic._internal._decorators_v1.V2CoreBeforeRootValidator","pydantic._internal._decorators_v1.V2CoreAfterRootValidator"],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"signature":{".class":"SymbolTableNode","cross_ref":"inspect.signature","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_decorators_v1.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_decorators_v1.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_decorators_v1.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..232cec78c09e2d8561b52e1ef823c5c3b55fe996 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_decorators_v1.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[12,8,11,3,5,6,8,9,1,1,1,1],"dep_prios":[5,10,5,5,5,5,20,5,5,30,30,30],"dependencies":["pydantic._internal._utils","pydantic_core.core_schema","pydantic.errors","__future__","inspect","typing","pydantic_core","typing_extensions","builtins","_frozen_importlib","_typeshed","abc"],"hash":"80556ed82bba095445f28d33c610082fa56a950c","id":"pydantic._internal._decorators_v1","ignore_all":true,"interface_hash":"2b50b83461a59d2d60ea6adedb99f088c2dcd2c8","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_decorators_v1.py","plugin_data":null,"size":6185,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_discriminated_union.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_discriminated_union.data.json new file mode 100644 index 0000000000000000000000000000000000000000..03437bc5174325891ed277759da5e895e3a2690b --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_discriminated_union.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic._internal._discriminated_union","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"CoreMetadata":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._core_metadata.CoreMetadata","kind":"Gdef"},"CoreSchema":{".class":"SymbolTableNode","cross_ref":"pydantic_core.core_schema.CoreSchema","kind":"Gdef"},"CoreSchemaField":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._core_utils.CoreSchemaField","kind":"Gdef"},"Discriminator":{".class":"SymbolTableNode","cross_ref":"pydantic.types.Discriminator","kind":"Gdef"},"Hashable":{".class":"SymbolTableNode","cross_ref":"typing.Hashable","kind":"Gdef"},"MissingDefinitionForUnionRef":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.Exception"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._discriminated_union.MissingDefinitionForUnionRef","name":"MissingDefinitionForUnionRef","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._discriminated_union.MissingDefinitionForUnionRef","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic._internal._discriminated_union","mro":["pydantic._internal._discriminated_union.MissingDefinitionForUnionRef","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","ref"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._discriminated_union.MissingDefinitionForUnionRef.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","ref"],"arg_types":["pydantic._internal._discriminated_union.MissingDefinitionForUnionRef","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of MissingDefinitionForUnionRef","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"ref":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._discriminated_union.MissingDefinitionForUnionRef.ref","name":"ref","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._discriminated_union.MissingDefinitionForUnionRef.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._discriminated_union.MissingDefinitionForUnionRef","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"PydanticUserError":{".class":"SymbolTableNode","cross_ref":"pydantic.errors.PydanticUserError","kind":"Gdef"},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef"},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"_ApplyInferredDiscriminator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._discriminated_union._ApplyInferredDiscriminator","name":"_ApplyInferredDiscriminator","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._discriminated_union._ApplyInferredDiscriminator","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic._internal._discriminated_union","mro":["pydantic._internal._discriminated_union._ApplyInferredDiscriminator","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","discriminator","definitions"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._discriminated_union._ApplyInferredDiscriminator.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","discriminator","definitions"],"arg_types":["pydantic._internal._discriminated_union._ApplyInferredDiscriminator","builtins.str",{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of _ApplyInferredDiscriminator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_apply_to_root":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","schema"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._discriminated_union._ApplyInferredDiscriminator._apply_to_root","name":"_apply_to_root","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","schema"],"arg_types":["pydantic._internal._discriminated_union._ApplyInferredDiscriminator",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_apply_to_root of _ApplyInferredDiscriminator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_choices_to_handle":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic._internal._discriminated_union._ApplyInferredDiscriminator._choices_to_handle","name":"_choices_to_handle","setter_type":null,"type":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"}],"extra_attrs":null,"type_ref":"builtins.list"}}},"_discriminator_alias":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic._internal._discriminated_union._ApplyInferredDiscriminator._discriminator_alias","name":"_discriminator_alias","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_handle_choice":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","choice"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._discriminated_union._ApplyInferredDiscriminator._handle_choice","name":"_handle_choice","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","choice"],"arg_types":["pydantic._internal._discriminated_union._ApplyInferredDiscriminator",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_handle_choice of _ApplyInferredDiscriminator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_infer_discriminator_values_for_choice":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","choice","source_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._discriminated_union._ApplyInferredDiscriminator._infer_discriminator_values_for_choice","name":"_infer_discriminator_values_for_choice","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","choice","source_name"],"arg_types":["pydantic._internal._discriminated_union._ApplyInferredDiscriminator",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_infer_discriminator_values_for_choice of _ApplyInferredDiscriminator","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str","builtins.int"],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_infer_discriminator_values_for_dataclass_choice":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","choice","source_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._discriminated_union._ApplyInferredDiscriminator._infer_discriminator_values_for_dataclass_choice","name":"_infer_discriminator_values_for_dataclass_choice","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","choice","source_name"],"arg_types":["pydantic._internal._discriminated_union._ApplyInferredDiscriminator",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.DataclassArgsSchema"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_infer_discriminator_values_for_dataclass_choice of _ApplyInferredDiscriminator","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str","builtins.int"],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_infer_discriminator_values_for_field":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","field","source"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._discriminated_union._ApplyInferredDiscriminator._infer_discriminator_values_for_field","name":"_infer_discriminator_values_for_field","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","field","source"],"arg_types":["pydantic._internal._discriminated_union._ApplyInferredDiscriminator",{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._core_utils.CoreSchemaField"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_infer_discriminator_values_for_field of _ApplyInferredDiscriminator","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str","builtins.int"],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_infer_discriminator_values_for_inner_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","schema","source"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._discriminated_union._ApplyInferredDiscriminator._infer_discriminator_values_for_inner_schema","name":"_infer_discriminator_values_for_inner_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","schema","source"],"arg_types":["pydantic._internal._discriminated_union._ApplyInferredDiscriminator",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_infer_discriminator_values_for_inner_schema of _ApplyInferredDiscriminator","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str","builtins.int"],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_infer_discriminator_values_for_model_choice":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","choice","source_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._discriminated_union._ApplyInferredDiscriminator._infer_discriminator_values_for_model_choice","name":"_infer_discriminator_values_for_model_choice","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","choice","source_name"],"arg_types":["pydantic._internal._discriminated_union._ApplyInferredDiscriminator",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.ModelFieldsSchema"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_infer_discriminator_values_for_model_choice of _ApplyInferredDiscriminator","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str","builtins.int"],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_infer_discriminator_values_for_typed_dict_choice":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","choice","source_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._discriminated_union._ApplyInferredDiscriminator._infer_discriminator_values_for_typed_dict_choice","name":"_infer_discriminator_values_for_typed_dict_choice","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","choice","source_name"],"arg_types":["pydantic._internal._discriminated_union._ApplyInferredDiscriminator",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.TypedDictSchema"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_infer_discriminator_values_for_typed_dict_choice of _ApplyInferredDiscriminator","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str","builtins.int"],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_is_discriminator_shared":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","choice"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._discriminated_union._ApplyInferredDiscriminator._is_discriminator_shared","name":"_is_discriminator_shared","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","choice"],"arg_types":["pydantic._internal._discriminated_union._ApplyInferredDiscriminator",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.TaggedUnionSchema"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_is_discriminator_shared of _ApplyInferredDiscriminator","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_is_nullable":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._discriminated_union._ApplyInferredDiscriminator._is_nullable","name":"_is_nullable","setter_type":null,"type":"builtins.bool"}},"_set_unique_choice_for_values":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","choice","values"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._discriminated_union._ApplyInferredDiscriminator._set_unique_choice_for_values","name":"_set_unique_choice_for_values","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","choice","values"],"arg_types":["pydantic._internal._discriminated_union._ApplyInferredDiscriminator",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str","builtins.int"],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_set_unique_choice_for_values of _ApplyInferredDiscriminator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_should_be_nullable":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._discriminated_union._ApplyInferredDiscriminator._should_be_nullable","name":"_should_be_nullable","setter_type":null,"type":"builtins.bool"}},"_tagged_union_choices":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic._internal._discriminated_union._ApplyInferredDiscriminator._tagged_union_choices","name":"_tagged_union_choices","setter_type":null,"type":{".class":"Instance","args":["typing.Hashable",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_used":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._discriminated_union._ApplyInferredDiscriminator._used","name":"_used","setter_type":null,"type":"builtins.bool"}},"apply":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","schema"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._discriminated_union._ApplyInferredDiscriminator.apply","name":"apply","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","schema"],"arg_types":["pydantic._internal._discriminated_union._ApplyInferredDiscriminator",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"apply of _ApplyInferredDiscriminator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"definitions":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._discriminated_union._ApplyInferredDiscriminator.definitions","name":"definitions","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"discriminator":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._discriminated_union._ApplyInferredDiscriminator.discriminator","name":"discriminator","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._discriminated_union._ApplyInferredDiscriminator.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._discriminated_union._ApplyInferredDiscriminator","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._discriminated_union.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._discriminated_union.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._discriminated_union.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._discriminated_union.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._discriminated_union.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._discriminated_union.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"_core_utils":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._core_utils","kind":"Gdef"},"apply_discriminator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["schema","discriminator","definitions"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._discriminated_union.apply_discriminator","name":"apply_discriminator","original_first_arg":"schema","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["schema","discriminator","definitions"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},{".class":"UnionType","items":["builtins.str","pydantic.types.Discriminator"],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"apply_discriminator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"cast":{".class":"SymbolTableNode","cross_ref":"typing.cast","kind":"Gdef"},"core_schema":{".class":"SymbolTableNode","cross_ref":"pydantic_core.core_schema","kind":"Gdef"},"set_discriminator_in_metadata":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["schema","discriminator"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._discriminated_union.set_discriminator_in_metadata","name":"set_discriminator_in_metadata","original_first_arg":"schema","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["schema","discriminator"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"set_discriminator_in_metadata","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_discriminated_union.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_discriminated_union.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_discriminated_union.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..17e61d4988efd6943df86f0739a46daf43581933 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_discriminated_union.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[9,16,3,6,8,9,15,1,4,6,1,1,1],"dep_prios":[5,25,5,10,5,20,25,5,5,5,5,30,30],"dependencies":["pydantic._internal._core_utils","pydantic._internal._core_metadata","collections.abc","pydantic_core.core_schema","pydantic.errors","pydantic._internal","pydantic.types","__future__","typing","pydantic_core","builtins","_frozen_importlib","abc"],"hash":"07b8446a052edf99ca3f69a26603cddec006e358","id":"pydantic._internal._discriminated_union","ignore_all":true,"interface_hash":"e7406bdcfc75208432cfe8d9e42801515a0e886f","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_discriminated_union.py","plugin_data":null,"size":25478,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_docs_extraction.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_docs_extraction.data.json new file mode 100644 index 0000000000000000000000000000000000000000..dfeee496e1a8848b549dd29858238cacabae8d9d --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_docs_extraction.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic._internal._docs_extraction","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"DocstringVisitor":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["ast.NodeVisitor"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._docs_extraction.DocstringVisitor","name":"DocstringVisitor","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._docs_extraction.DocstringVisitor","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic._internal._docs_extraction","mro":["pydantic._internal._docs_extraction.DocstringVisitor","ast.NodeVisitor","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._docs_extraction.DocstringVisitor.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._docs_extraction.DocstringVisitor"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of DocstringVisitor","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"attrs":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic._internal._docs_extraction.DocstringVisitor.attrs","name":"attrs","setter_type":null,"type":{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"previous_node_type":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic._internal._docs_extraction.DocstringVisitor.previous_node_type","name":"previous_node_type","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeType","item":"ast.AST"},{".class":"NoneType"}],"uses_pep604_syntax":true}}},"target":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic._internal._docs_extraction.DocstringVisitor.target","name":"target","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"visit":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","node"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._docs_extraction.DocstringVisitor.visit","name":"visit","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","node"],"arg_types":["pydantic._internal._docs_extraction.DocstringVisitor","ast.AST"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"visit of DocstringVisitor","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"visit_AnnAssign":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","node"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._docs_extraction.DocstringVisitor.visit_AnnAssign","name":"visit_AnnAssign","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","node"],"arg_types":["pydantic._internal._docs_extraction.DocstringVisitor","ast.AnnAssign"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"visit_AnnAssign of DocstringVisitor","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"visit_Expr":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","node"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._docs_extraction.DocstringVisitor.visit_Expr","name":"visit_Expr","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","node"],"arg_types":["pydantic._internal._docs_extraction.DocstringVisitor","ast.Expr"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"visit_Expr of DocstringVisitor","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._docs_extraction.DocstringVisitor.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._docs_extraction.DocstringVisitor","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._docs_extraction.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._docs_extraction.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._docs_extraction.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._docs_extraction.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._docs_extraction.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._docs_extraction.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_dedent_source_lines":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["source"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._docs_extraction._dedent_source_lines","name":"_dedent_source_lines","original_first_arg":"source","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["source"],"arg_types":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_dedent_source_lines","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_extract_source_from_frame":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._docs_extraction._extract_source_from_frame","name":"_extract_source_from_frame","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_extract_source_from_frame","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"ast":{".class":"SymbolTableNode","cross_ref":"ast","kind":"Gdef"},"extract_docstrings_from_cls":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["cls","use_inspect"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._docs_extraction.extract_docstrings_from_cls","name":"extract_docstrings_from_cls","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["cls","use_inspect"],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"extract_docstrings_from_cls","ret_type":{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"inspect":{".class":"SymbolTableNode","cross_ref":"inspect","kind":"Gdef"},"sys":{".class":"SymbolTableNode","cross_ref":"sys","kind":"Gdef"},"textwrap":{".class":"SymbolTableNode","cross_ref":"textwrap","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_docs_extraction.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_docs_extraction.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_docs_extraction.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..a595f21dd8b411206d3872b12ce2afcf28b8af97 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_docs_extraction.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[3,5,6,7,8,9,1,1,1],"dep_prios":[5,10,10,10,10,5,5,30,30],"dependencies":["__future__","ast","inspect","sys","textwrap","typing","builtins","_frozen_importlib","abc"],"hash":"847dd356d564369206b968a2ab8e6fa6e7e27d61","id":"pydantic._internal._docs_extraction","ignore_all":true,"interface_hash":"03c8a763789c6be5cb48c3d439cb2ea88c7c7d08","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_docs_extraction.py","plugin_data":null,"size":4127,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_fields.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_fields.data.json new file mode 100644 index 0000000000000000000000000000000000000000..39e13e4c2997b3c774012cf5e1b61ebba3ee2cc5 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_fields.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic._internal._fields","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","AliasGenerator":{".class":"SymbolTableNode","cross_ref":"pydantic.aliases.AliasGenerator","kind":"Gdef"},"AnnotationSource":{".class":"SymbolTableNode","cross_ref":"typing_inspection.introspection.AnnotationSource","kind":"Gdef"},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseMetadata":{".class":"SymbolTableNode","cross_ref":"annotated_types.BaseMetadata","kind":"Gdef"},"BaseModel":{".class":"SymbolTableNode","cross_ref":"pydantic.main.BaseModel","kind":"Gdef"},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"ConfigWrapper":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._config.ConfigWrapper","kind":"Gdef"},"DecoratorInfos":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._decorators.DecoratorInfos","kind":"Gdef"},"FieldInfo":{".class":"SymbolTableNode","cross_ref":"pydantic.fields.FieldInfo","kind":"Gdef"},"Mapping":{".class":"SymbolTableNode","cross_ref":"typing.Mapping","kind":"Gdef"},"NsResolver":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._namespace_utils.NsResolver","kind":"Gdef"},"Parameter":{".class":"SymbolTableNode","cross_ref":"inspect.Parameter","kind":"Gdef"},"Pattern":{".class":"SymbolTableNode","cross_ref":"re.Pattern","kind":"Gdef"},"PydanticDataclass":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._dataclasses.PydanticDataclass","kind":"Gdef"},"PydanticDeprecatedSince211":{".class":"SymbolTableNode","cross_ref":"pydantic.warnings.PydanticDeprecatedSince211","kind":"Gdef"},"PydanticMetadata":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic._internal._repr.Representation"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._fields.PydanticMetadata","name":"PydanticMetadata","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._fields.PydanticMetadata","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic._internal._fields","mro":["pydantic._internal._fields.PydanticMetadata","pydantic._internal._repr.Representation","builtins.object"],"names":{".class":"SymbolTable","__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic._internal._fields.PydanticMetadata.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._fields.PydanticMetadata.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._fields.PydanticMetadata","values":[],"variance":0},"slots":[],"tuple_type":null,"type_vars":[],"typeddict_type":null}},"PydanticUndefined":{".class":"SymbolTableNode","cross_ref":"pydantic_core._pydantic_core.PydanticUndefined","kind":"Gdef"},"PydanticUserError":{".class":"SymbolTableNode","cross_ref":"pydantic.errors.PydanticUserError","kind":"Gdef"},"Representation":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._repr.Representation","kind":"Gdef"},"StandardDataclass":{".class":"SymbolTableNode","cross_ref":"_typeshed.DataclassInstance","kind":"Gdef"},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"TypeIs":{".class":"SymbolTableNode","cross_ref":"typing_extensions.TypeIs","kind":"Gdef"},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._fields.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._fields.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._fields.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._fields.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._fields.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._fields.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"_apply_alias_generator_to_field_info":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["alias_generator","field_name","field_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._fields._apply_alias_generator_to_field_info","name":"_apply_alias_generator_to_field_info","original_first_arg":"alias_generator","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["alias_generator","field_name","field_info"],"arg_types":[{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"pydantic.aliases.AliasGenerator"],"uses_pep604_syntax":true},"builtins.str","pydantic.fields.FieldInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_apply_alias_generator_to_field_info","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_apply_field_title_generator_to_field_info":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["title_generator","field_name","field_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._fields._apply_field_title_generator_to_field_info","name":"_apply_field_title_generator_to_field_info","original_first_arg":"title_generator","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["title_generator","field_name","field_info"],"arg_types":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["builtins.str","pydantic.fields.FieldInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"builtins.str","pydantic.fields.FieldInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_apply_field_title_generator_to_field_info","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_check_protected_namespaces":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["protected_namespaces","ann_name","bases","cls_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._fields._check_protected_namespaces","name":"_check_protected_namespaces","original_first_arg":"protected_namespaces","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["protected_namespaces","ann_name","bases","cls_name"],"arg_types":[{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.tuple"},"builtins.str",{".class":"Instance","args":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"extra_attrs":null,"type_ref":"builtins.tuple"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_check_protected_namespaces","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_deprecated_classmethod_names":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._fields._deprecated_classmethod_names","name":"_deprecated_classmethod_names","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"_deprecated_method_names":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._fields._deprecated_method_names","name":"_deprecated_method_names","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"_general_metadata_cls":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated"],"fullname":"pydantic._internal._fields._general_metadata_cls","name":"_general_metadata_cls","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_general_metadata_cls","ret_type":{".class":"TypeType","item":"annotated_types.BaseMetadata"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._fields._general_metadata_cls","name":"_general_metadata_cls","setter_type":null,"type":{".class":"Instance","args":[{".class":"TypeType","item":"annotated_types.BaseMetadata"}],"extra_attrs":null,"type_ref":"functools._lru_cache_wrapper"}}}},"_generics":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._generics","kind":"Gdef"},"_typing_extra":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._typing_extra","kind":"Gdef"},"_update_fields_from_docstrings":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["cls","fields","use_inspect"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._fields._update_fields_from_docstrings","name":"_update_fields_from_docstrings","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["cls","fields","use_inspect"],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},{".class":"Instance","args":["builtins.str","pydantic.fields.FieldInfo"],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_update_fields_from_docstrings","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"cache":{".class":"SymbolTableNode","cross_ref":"functools.cache","kind":"Gdef"},"can_be_positional":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._utils.can_be_positional","kind":"Gdef"},"collect_dataclass_fields":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,5,5],"arg_names":["cls","config_wrapper","ns_resolver","typevars_map"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._fields.collect_dataclass_fields","name":"collect_dataclass_fields","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,3,5,5],"arg_names":["cls","config_wrapper","ns_resolver","typevars_map"],"arg_types":[{".class":"TypeType","item":"_typeshed.DataclassInstance"},"pydantic._internal._config.ConfigWrapper",{".class":"UnionType","items":["pydantic._internal._namespace_utils.NsResolver",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"collect_dataclass_fields","ret_type":{".class":"Instance","args":["builtins.str","pydantic.fields.FieldInfo"],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"collect_model_fields":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5],"arg_names":["cls","config_wrapper","ns_resolver","typevars_map"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._fields.collect_model_fields","name":"collect_model_fields","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0,0,5],"arg_names":["cls","config_wrapper","ns_resolver","typevars_map"],"arg_types":[{".class":"TypeType","item":"pydantic.main.BaseModel"},"pydantic._internal._config.ConfigWrapper",{".class":"UnionType","items":["pydantic._internal._namespace_utils.NsResolver",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":["typing.TypeVar",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"collect_model_fields","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"Instance","args":["builtins.str","pydantic.fields.FieldInfo"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"dataclasses":{".class":"SymbolTableNode","cross_ref":"dataclasses","kind":"Gdef"},"extract_docstrings_from_cls":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._docs_extraction.extract_docstrings_from_cls","kind":"Gdef"},"get_first_not_none":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._utils.get_first_not_none","kind":"Gdef"},"import_cached_base_model":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._import_utils.import_cached_base_model","kind":"Gdef"},"import_cached_field_info":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._import_utils.import_cached_field_info","kind":"Gdef"},"is_valid_field_name":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._fields.is_valid_field_name","name":"is_valid_field_name","original_first_arg":"name","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["name"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_valid_field_name","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_valid_privateattr_name":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._fields.is_valid_privateattr_name","name":"is_valid_privateattr_name","original_first_arg":"name","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["name"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_valid_privateattr_name","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"ismethoddescriptor":{".class":"SymbolTableNode","cross_ref":"inspect.ismethoddescriptor","kind":"Gdef"},"pydantic_general_metadata":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[4],"arg_names":["metadata"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._fields.pydantic_general_metadata","name":"pydantic_general_metadata","original_first_arg":"metadata","type":{".class":"CallableType","arg_kinds":[4],"arg_names":["metadata"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pydantic_general_metadata","ret_type":"annotated_types.BaseMetadata","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"rebuild_dataclass_fields":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,3,3],"arg_names":["cls","config_wrapper","ns_resolver","typevars_map"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._fields.rebuild_dataclass_fields","name":"rebuild_dataclass_fields","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,3,3,3],"arg_names":["cls","config_wrapper","ns_resolver","typevars_map"],"arg_types":[{".class":"TypeType","item":"pydantic._internal._dataclasses.PydanticDataclass"},"pydantic._internal._config.ConfigWrapper","pydantic._internal._namespace_utils.NsResolver",{".class":"Instance","args":["typing.TypeVar",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Mapping"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rebuild_dataclass_fields","ret_type":{".class":"Instance","args":["builtins.str","pydantic.fields.FieldInfo"],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"rebuild_model_fields":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,3,3],"arg_names":["cls","config_wrapper","ns_resolver","typevars_map"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._fields.rebuild_model_fields","name":"rebuild_model_fields","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,3,3,3],"arg_names":["cls","config_wrapper","ns_resolver","typevars_map"],"arg_types":[{".class":"TypeType","item":"pydantic.main.BaseModel"},"pydantic._internal._config.ConfigWrapper","pydantic._internal._namespace_utils.NsResolver",{".class":"Instance","args":["typing.TypeVar",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Mapping"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rebuild_model_fields","ret_type":{".class":"Instance","args":["builtins.str","pydantic.fields.FieldInfo"],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"signature":{".class":"SymbolTableNode","cross_ref":"inspect.signature","kind":"Gdef"},"takes_validated_data_argument":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["default_factory"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._fields.takes_validated_data_argument","name":"takes_validated_data_argument","original_first_arg":"default_factory","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["default_factory"],"arg_types":[{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"takes_validated_data_argument","ret_type":"builtins.bool","type_guard":null,"type_is":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"unpack_kwargs":false,"variables":[]}}},"update_field_from_config":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["config_wrapper","field_name","field_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._fields.update_field_from_config","name":"update_field_from_config","original_first_arg":"config_wrapper","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["config_wrapper","field_name","field_info"],"arg_types":["pydantic._internal._config.ConfigWrapper","builtins.str","pydantic.fields.FieldInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"update_field_from_config","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"warnings":{".class":"SymbolTableNode","cross_ref":"warnings","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_fields.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_fields.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_fields.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..63192bb386497de54897d6e908d07c99b866bab3 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_fields.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[21,21,22,23,24,25,26,27,34,35,7,15,18,20,21,32,33,3,5,6,8,9,10,11,13,14,17,30,1,1,1,1,1],"dep_prios":[10,10,5,5,5,5,5,5,25,25,5,5,5,5,20,25,25,5,10,10,5,5,5,5,5,5,5,25,5,30,30,30,30],"dependencies":["pydantic._internal._generics","pydantic._internal._typing_extra","pydantic._internal._config","pydantic._internal._docs_extraction","pydantic._internal._import_utils","pydantic._internal._namespace_utils","pydantic._internal._repr","pydantic._internal._utils","pydantic._internal._dataclasses","pydantic._internal._decorators","collections.abc","typing_inspection.introspection","pydantic.errors","pydantic.aliases","pydantic._internal","pydantic.fields","pydantic.main","__future__","dataclasses","warnings","functools","inspect","re","typing","pydantic_core","typing_extensions","pydantic","annotated_types","builtins","_frozen_importlib","_typeshed","abc","pydantic._internal._model_construction"],"hash":"9b5ae0f3fc567ea15ceaf884202c44128f3df8c5","id":"pydantic._internal._fields","ignore_all":true,"interface_hash":"85806eec328a060fe6bb8596dfa3ee83ef2c1cbc","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_fields.py","plugin_data":null,"size":28093,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_forward_ref.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_forward_ref.data.json new file mode 100644 index 0000000000000000000000000000000000000000..e2cc6bc938b96fa128203dcc4e5e71b4ff015c5d --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_forward_ref.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic._internal._forward_ref","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","PydanticRecursiveRef":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._forward_ref.PydanticRecursiveRef","name":"PydanticRecursiveRef","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._forward_ref.PydanticRecursiveRef","has_param_spec_type":false,"metaclass_type":null,"metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":9,"name":"type_ref","type":"builtins.str"}],"frozen":false},"dataclass_tag":{}},"module_name":"pydantic._internal._forward_ref","mro":["pydantic._internal._forward_ref.PydanticRecursiveRef","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._forward_ref.PydanticRecursiveRef.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._forward_ref.PydanticRecursiveRef"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of PydanticRecursiveRef","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"pydantic._internal._forward_ref.PydanticRecursiveRef.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"dataclasses.Field"}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__hash__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._forward_ref.PydanticRecursiveRef.__hash__","name":"__hash__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","type_ref"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._forward_ref.PydanticRecursiveRef.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","type_ref"],"arg_types":["pydantic._internal._forward_ref.PydanticRecursiveRef","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of PydanticRecursiveRef","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5],"arg_names":["type_ref"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"pydantic._internal._forward_ref.PydanticRecursiveRef.__mypy-replace","name":"__mypy-replace","original_first_arg":"type_ref","type":{".class":"CallableType","arg_kinds":[5],"arg_names":["type_ref"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of PydanticRecursiveRef","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"pydantic._internal._forward_ref.PydanticRecursiveRef.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5],"arg_names":["type_ref"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of PydanticRecursiveRef","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"__name__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._forward_ref.PydanticRecursiveRef.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__or__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._forward_ref.PydanticRecursiveRef.__or__","name":"__or__","original_first_arg":"self","type":null}},"__ror__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._forward_ref.PydanticRecursiveRef.__ror__","name":"__ror__","original_first_arg":"self","type":null}},"type_ref":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._forward_ref.PydanticRecursiveRef.type_ref","name":"type_ref","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._forward_ref.PydanticRecursiveRef.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._forward_ref.PydanticRecursiveRef","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._forward_ref.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._forward_ref.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._forward_ref.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._forward_ref.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._forward_ref.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._forward_ref.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"dataclass":{".class":"SymbolTableNode","cross_ref":"dataclasses.dataclass","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_forward_ref.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_forward_ref.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_forward_ref.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..04528f89d0563176bbe1c7a14ec3943172a8b3fb --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_forward_ref.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106714,"dep_lines":[1,3,4,1,1,1],"dep_prios":[5,5,5,5,30,30],"dependencies":["__future__","dataclasses","typing","builtins","_frozen_importlib","abc"],"hash":"80aff545a3f3e15de5a7ac4c94c17f0a03bba088","id":"pydantic._internal._forward_ref","ignore_all":true,"interface_hash":"4cdc35e1f3c876d72be7bb2017d79eedb01999cf","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_forward_ref.py","plugin_data":null,"size":611,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_generate_schema.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_generate_schema.data.json new file mode 100644 index 0000000000000000000000000000000000000000..ee3eb0ca3a860bed141b738969b4f9f405fd0d07 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_generate_schema.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic._internal._generate_schema","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","AfterValidator":{".class":"SymbolTableNode","cross_ref":"pydantic.functional_validators.AfterValidator","kind":"Gdef"},"AliasChoices":{".class":"SymbolTableNode","cross_ref":"pydantic.aliases.AliasChoices","kind":"Gdef"},"AliasPath":{".class":"SymbolTableNode","cross_ref":"pydantic.aliases.AliasPath","kind":"Gdef"},"AnnotationSource":{".class":"SymbolTableNode","cross_ref":"typing_inspection.introspection.AnnotationSource","kind":"Gdef"},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"AnyFieldDecorator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic._internal._generate_schema.AnyFieldDecorator","line":121,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"Instance","args":["pydantic._internal._decorators.ValidatorDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"},{".class":"Instance","args":["pydantic._internal._decorators.FieldValidatorDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"},{".class":"Instance","args":["pydantic._internal._decorators.FieldSerializerDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"uses_pep604_syntax":false}}},"ArbitraryTypeWarning":{".class":"SymbolTableNode","cross_ref":"pydantic.warnings.ArbitraryTypeWarning","kind":"Gdef"},"BaseModel":{".class":"SymbolTableNode","cross_ref":"pydantic.main.BaseModel","kind":"Gdef"},"BeforeValidator":{".class":"SymbolTableNode","cross_ref":"pydantic.functional_validators.BeforeValidator","kind":"Gdef"},"COUNTER_TYPES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._generate_schema.COUNTER_TYPES","name":"COUNTER_TYPES","setter_type":null,"type":{".class":"Instance","args":[{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[1],"arg_names":[null],"arg_types":[{".class":"NoneType"}],"fallback":"abc.ABCMeta","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":"Counter","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"collections._T","id":1,"name":"_T","namespace":"collections.Counter","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"collections.Counter"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"collections._T","id":1,"name":"_T","namespace":"collections.Counter","upper_bound":"builtins.object","values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[1,4],"arg_names":[null,"kwargs"],"arg_types":[{".class":"NoneType"},"builtins.int"],"fallback":"abc.ABCMeta","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":"Counter","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"collections.Counter"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"collections._T","id":1,"name":"_T","namespace":"collections.Counter","upper_bound":"builtins.object","values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"collections._T","id":1,"name":"_T","namespace":"collections.Counter","upper_bound":"builtins.object","values":[],"variance":0},"builtins.int"],"extra_attrs":null,"type_ref":"_typeshed.SupportsKeysAndGetItem"}],"fallback":"abc.ABCMeta","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":"Counter","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"collections._T","id":1,"name":"_T","namespace":"collections.Counter","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"collections.Counter"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"collections._T","id":1,"name":"_T","namespace":"collections.Counter","upper_bound":"builtins.object","values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"collections._T","id":1,"name":"_T","namespace":"collections.Counter","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"abc.ABCMeta","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":"Counter","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"collections._T","id":1,"name":"_T","namespace":"collections.Counter","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"collections.Counter"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"collections._T","id":1,"name":"_T","namespace":"collections.Counter","upper_bound":"builtins.object","values":[],"variance":0}]}]}],"extra_attrs":null,"type_ref":"builtins.list"}}},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"CallbackGetCoreSchemaHandler":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._schema_generation_shared.CallbackGetCoreSchemaHandler","kind":"Gdef"},"ComputedFieldInfo":{".class":"SymbolTableNode","cross_ref":"pydantic.fields.ComputedFieldInfo","kind":"Gdef"},"ConfigDict":{".class":"SymbolTableNode","cross_ref":"pydantic.config.ConfigDict","kind":"Gdef"},"ConfigWrapper":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._config.ConfigWrapper","kind":"Gdef"},"ConfigWrapperStack":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._config.ConfigWrapperStack","kind":"Gdef"},"CoreMetadata":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._core_metadata.CoreMetadata","kind":"Gdef"},"CoreSchema":{".class":"SymbolTableNode","cross_ref":"pydantic_core.core_schema.CoreSchema","kind":"Gdef"},"DEQUE_TYPES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic._internal._generate_schema.DEQUE_TYPES","name":"DEQUE_TYPES","setter_type":null,"type":{".class":"Instance","args":["builtins.type"],"extra_attrs":null,"type_ref":"builtins.list"}}},"DICT_TYPES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic._internal._generate_schema.DICT_TYPES","name":"DICT_TYPES","setter_type":null,"type":{".class":"Instance","args":["builtins.type"],"extra_attrs":null,"type_ref":"builtins.list"}}},"Decimal":{".class":"SymbolTableNode","cross_ref":"decimal.Decimal","kind":"Gdef"},"Decorator":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._decorators.Decorator","kind":"Gdef"},"DecoratorInfos":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._decorators.DecoratorInfos","kind":"Gdef"},"Discriminator":{".class":"SymbolTableNode","cross_ref":"pydantic.types.Discriminator","kind":"Gdef"},"Enum":{".class":"SymbolTableNode","cross_ref":"enum.Enum","kind":"Gdef"},"FROZEN_SET_TYPES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic._internal._generate_schema.FROZEN_SET_TYPES","name":"FROZEN_SET_TYPES","setter_type":null,"type":{".class":"Instance","args":["builtins.type"],"extra_attrs":null,"type_ref":"builtins.list"}}},"FieldDecoratorInfo":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic._internal._generate_schema.FieldDecoratorInfo","line":119,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["pydantic._internal._decorators.ValidatorDecoratorInfo","pydantic._internal._decorators.FieldValidatorDecoratorInfo","pydantic._internal._decorators.FieldSerializerDecoratorInfo"],"uses_pep604_syntax":false}}},"FieldDecoratorInfoType":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._generate_schema.FieldDecoratorInfoType","name":"FieldDecoratorInfoType","upper_bound":{".class":"UnionType","items":["pydantic._internal._decorators.ValidatorDecoratorInfo","pydantic._internal._decorators.FieldValidatorDecoratorInfo","pydantic._internal._decorators.FieldSerializerDecoratorInfo"],"uses_pep604_syntax":false},"values":[],"variance":0}},"FieldInfo":{".class":"SymbolTableNode","cross_ref":"pydantic.fields.FieldInfo","kind":"Gdef"},"FieldSerializerDecoratorInfo":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._decorators.FieldSerializerDecoratorInfo","kind":"Gdef"},"FieldValidatorDecoratorInfo":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._decorators.FieldValidatorDecoratorInfo","kind":"Gdef"},"FieldValidatorModes":{".class":"SymbolTableNode","cross_ref":"pydantic.functional_validators.FieldValidatorModes","kind":"Gdef"},"Final":{".class":"SymbolTableNode","cross_ref":"typing.Final","kind":"Gdef"},"ForwardRef":{".class":"SymbolTableNode","cross_ref":"typing.ForwardRef","kind":"Gdef"},"Fraction":{".class":"SymbolTableNode","cross_ref":"fractions.Fraction","kind":"Gdef"},"FunctionType":{".class":"SymbolTableNode","cross_ref":"types.FunctionType","kind":"Gdef"},"GenerateSchema":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._generate_schema.GenerateSchema","name":"GenerateSchema","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._generate_schema.GenerateSchema","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic._internal._generate_schema","mro":["pydantic._internal._generate_schema.GenerateSchema","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","config_wrapper","ns_resolver","typevars_map"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","config_wrapper","ns_resolver","typevars_map"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema","pydantic._internal._config.ConfigWrapper",{".class":"UnionType","items":["pydantic._internal._namespace_utils.NsResolver",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":["typing.TypeVar",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of GenerateSchema","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init_subclass__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema.__init_subclass__","name":"__init_subclass__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic._internal._generate_schema.GenerateSchema"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init_subclass__ of GenerateSchema","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic._internal._generate_schema.GenerateSchema.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_add_js_function":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","metadata_schema","js_function"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._add_js_function","name":"_add_js_function","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","metadata_schema","js_function"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_add_js_function of GenerateSchema","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_annotated_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","annotated_type"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._annotated_schema","name":"_annotated_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","annotated_type"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_annotated_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_apply_annotations":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1],"arg_names":["self","source_type","annotations","transform_inner_schema","check_unsupported_field_info_attributes"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._apply_annotations","name":"_apply_annotations","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1],"arg_names":["self","source_type","annotations","transform_inner_schema","check_unsupported_field_info_attributes"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_apply_annotations of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_apply_discriminator_to_union":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","schema","discriminator"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._apply_discriminator_to_union","name":"_apply_discriminator_to_union","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","schema","discriminator"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},{".class":"UnionType","items":["builtins.str","pydantic.types.Discriminator",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_apply_discriminator_to_union of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_apply_field_serializers":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","schema","serializers"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._apply_field_serializers","name":"_apply_field_serializers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","schema","serializers"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},{".class":"Instance","args":[{".class":"Instance","args":["pydantic._internal._decorators.FieldSerializerDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_apply_field_serializers of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_apply_model_serializers":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","schema","serializers"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._apply_model_serializers","name":"_apply_model_serializers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","schema","serializers"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},{".class":"Instance","args":[{".class":"Instance","args":["pydantic._internal._decorators.ModelSerializerDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_apply_model_serializers of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_apply_single_annotation":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","schema","metadata","check_unsupported_field_info_attributes"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._apply_single_annotation","name":"_apply_single_annotation","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","schema","metadata","check_unsupported_field_info_attributes"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_apply_single_annotation of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_apply_single_annotation_json_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","schema","metadata"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._apply_single_annotation_json_schema","name":"_apply_single_annotation_json_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","schema","metadata"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_apply_single_annotation_json_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_arbitrary_type_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","tp"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._arbitrary_type_schema","name":"_arbitrary_type_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","tp"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_arbitrary_type_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_arbitrary_types":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._arbitrary_types","name":"_arbitrary_types","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_arbitrary_types of GenerateSchema","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._arbitrary_types","name":"_arbitrary_types","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_arbitrary_types of GenerateSchema","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"_arguments_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","function","parameters_callback"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._arguments_schema","name":"_arguments_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","function","parameters_callback"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._generate_schema.ValidateCallSupportedTypes"},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._generate_schema.ParametersCallback"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_arguments_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.ArgumentsSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_arguments_v3_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","function","parameters_callback"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._arguments_v3_schema","name":"_arguments_v3_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","function","parameters_callback"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._generate_schema.ValidateCallSupportedTypes"},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._generate_schema.ParametersCallback"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_arguments_v3_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.ArgumentsV3Schema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_call_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","function"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._call_schema","name":"_call_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","function"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._generate_schema.ValidateCallSupportedTypes"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_call_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CallSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_common_field_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","name","field_info","decorators"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._common_field_schema","name":"_common_field_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","name","field_info","decorators"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema","builtins.str","pydantic.fields.FieldInfo","pydantic._internal._decorators.DecoratorInfos"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_common_field_schema of GenerateSchema","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_computed_field_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","d","field_serializers"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._computed_field_schema","name":"_computed_field_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","d","field_serializers"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"Instance","args":["pydantic.fields.ComputedFieldInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"},{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic._internal._decorators.FieldSerializerDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_computed_field_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.ComputedField"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_config_wrapper":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._config_wrapper","name":"_config_wrapper","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_config_wrapper of GenerateSchema","ret_type":"pydantic._internal._config.ConfigWrapper","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._config_wrapper","name":"_config_wrapper","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_config_wrapper of GenerateSchema","ret_type":"pydantic._internal._config.ConfigWrapper","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"_config_wrapper_stack":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._config_wrapper_stack","name":"_config_wrapper_stack","setter_type":null,"type":"pydantic._internal._config.ConfigWrapperStack"}},"_dataclass_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","dataclass","origin"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._dataclass_schema","name":"_dataclass_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","dataclass","origin"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"TypeType","item":"_typeshed.DataclassInstance"},{".class":"UnionType","items":[{".class":"TypeType","item":"_typeshed.DataclassInstance"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_dataclass_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_deque_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","items_type"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._deque_schema","name":"_deque_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","items_type"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_deque_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_dict_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","keys_type","values_type"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._dict_schema","name":"_dict_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","keys_type","values_type"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_dict_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_enum_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","enum_type"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._enum_schema","name":"_enum_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","enum_type"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"TypeType","item":"enum.Enum"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_enum_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_fraction_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._fraction_schema","name":"_fraction_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_fraction_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_frozenset_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","items_type"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._frozenset_schema","name":"_frozenset_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","items_type"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_frozenset_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_generate_dc_field_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","name","field_info","decorators"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._generate_dc_field_schema","name":"_generate_dc_field_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","name","field_info","decorators"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema","builtins.str","pydantic.fields.FieldInfo","pydantic._internal._decorators.DecoratorInfos"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_generate_dc_field_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.DataclassField"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_generate_md_field_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","name","field_info","decorators"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._generate_md_field_schema","name":"_generate_md_field_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","name","field_info","decorators"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema","builtins.str","pydantic.fields.FieldInfo","pydantic._internal._decorators.DecoratorInfos"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_generate_md_field_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.ModelField"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_generate_parameter_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1,1],"arg_names":["self","name","annotation","source","default","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._generate_parameter_schema","name":"_generate_parameter_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,1],"arg_names":["self","name","annotation","source","default","mode"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema","builtins.str",{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},"typing_inspection.introspection.AnnotationSource",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"positional_only"},{".class":"LiteralType","fallback":"builtins.str","value":"positional_or_keyword"},{".class":"LiteralType","fallback":"builtins.str","value":"keyword_only"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_generate_parameter_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.ArgumentsParameter"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_generate_parameter_v3_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0,1],"arg_names":["self","name","annotation","source","mode","default"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._generate_parameter_v3_schema","name":"_generate_parameter_v3_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,1],"arg_names":["self","name","annotation","source","mode","default"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema","builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"typing_inspection.introspection.AnnotationSource",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"positional_only"},{".class":"LiteralType","fallback":"builtins.str","value":"positional_or_keyword"},{".class":"LiteralType","fallback":"builtins.str","value":"keyword_only"},{".class":"LiteralType","fallback":"builtins.str","value":"var_args"},{".class":"LiteralType","fallback":"builtins.str","value":"var_kwargs_uniform"},{".class":"LiteralType","fallback":"builtins.str","value":"var_kwargs_unpacked_typed_dict"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_generate_parameter_v3_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.ArgumentsV3Parameter"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_generate_schema_from_get_schema_method":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","obj","source"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._generate_schema_from_get_schema_method","name":"_generate_schema_from_get_schema_method","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","obj","source"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_generate_schema_from_get_schema_method of GenerateSchema","ret_type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_generate_schema_inner":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._generate_schema_inner","name":"_generate_schema_inner","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","obj"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_generate_schema_inner of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_generate_td_field_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,5],"arg_names":["self","name","field_info","decorators","required"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._generate_td_field_schema","name":"_generate_td_field_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,5],"arg_names":["self","name","field_info","decorators","required"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema","builtins.str","pydantic.fields.FieldInfo","pydantic._internal._decorators.DecoratorInfos","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_generate_td_field_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.TypedDictField"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_get_args_resolving_forward_refs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"pydantic._internal._generate_schema.GenerateSchema._get_args_resolving_forward_refs","impl":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","obj","required"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._get_args_resolving_forward_refs","name":"_get_args_resolving_forward_refs","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","obj","required"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_args_resolving_forward_refs of GenerateSchema","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","obj","required"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._get_args_resolving_forward_refs","name":"_get_args_resolving_forward_refs","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","obj","required"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_args_resolving_forward_refs of GenerateSchema","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._get_args_resolving_forward_refs","name":"_get_args_resolving_forward_refs","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","obj","required"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_args_resolving_forward_refs of GenerateSchema","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._get_args_resolving_forward_refs","name":"_get_args_resolving_forward_refs","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","obj"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_args_resolving_forward_refs of GenerateSchema","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._get_args_resolving_forward_refs","name":"_get_args_resolving_forward_refs","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","obj"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_args_resolving_forward_refs of GenerateSchema","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","obj","required"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_args_resolving_forward_refs of GenerateSchema","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","obj"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_args_resolving_forward_refs of GenerateSchema","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"_get_first_arg_or_any":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._get_first_arg_or_any","name":"_get_first_arg_or_any","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","obj"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_first_arg_or_any of GenerateSchema","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_get_first_two_args_or_any":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._get_first_two_args_or_any","name":"_get_first_two_args_or_any","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","obj"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_first_two_args_or_any of GenerateSchema","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_get_unsupported_field_info_attributes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","field_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._get_unsupported_field_info_attributes","name":"_get_unsupported_field_info_attributes","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","field_info"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema","pydantic.fields.FieldInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_unsupported_field_info_attributes of GenerateSchema","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_get_wrapped_inner_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1],"arg_names":["self","get_inner_schema","annotation","pydantic_js_annotation_functions","check_unsupported_field_info_attributes"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._get_wrapped_inner_schema","name":"_get_wrapped_inner_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","get_inner_schema","annotation","pydantic_js_annotation_functions","check_unsupported_field_info_attributes"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema","pydantic.annotated_handlers.GetCoreSchemaHandler",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._schema_generation_shared.GetJsonSchemaFunction"}],"extra_attrs":null,"type_ref":"builtins.list"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_wrapped_inner_schema of GenerateSchema","ret_type":"pydantic._internal._schema_generation_shared.CallbackGetCoreSchemaHandler","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_hashable_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._hashable_schema","name":"_hashable_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_hashable_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_ip_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","tp"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._ip_schema","name":"_ip_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","tp"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_ip_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_iterable_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","type_"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._iterable_schema","name":"_iterable_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","type_"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_iterable_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.GeneratorSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_list_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","items_type"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._list_schema","name":"_list_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","items_type"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_list_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_literal_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","literal_type"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._literal_schema","name":"_literal_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","literal_type"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_literal_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_mapping_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","tp","keys_type","values_type"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._mapping_schema","name":"_mapping_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","tp","keys_type","values_type"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_mapping_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_match_generic_type":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","obj","origin"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._match_generic_type","name":"_match_generic_type","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","obj","origin"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_match_generic_type of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_model_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._model_schema","name":"_model_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","cls"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"TypeType","item":"pydantic.main.BaseModel"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_model_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_namedtuple_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","namedtuple_cls","origin"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._namedtuple_schema","name":"_namedtuple_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","namedtuple_cls","origin"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_namedtuple_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_ns_resolver":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._ns_resolver","name":"_ns_resolver","setter_type":null,"type":"pydantic._internal._namespace_utils.NsResolver"}},"_path_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","tp","path_type"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._path_schema","name":"_path_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","tp","path_type"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_path_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_pattern_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","pattern_type"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._pattern_schema","name":"_pattern_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","pattern_type"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_pattern_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_resolve_forward_ref":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._resolve_forward_ref","name":"_resolve_forward_ref","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","obj"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_resolve_forward_ref of GenerateSchema","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_resolve_self_type":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._resolve_self_type","name":"_resolve_self_type","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","obj"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_resolve_self_type of GenerateSchema","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_sequence_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","items_type"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._sequence_schema","name":"_sequence_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","items_type"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_sequence_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_set_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","items_type"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._set_schema","name":"_set_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","items_type"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_set_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_subclass_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","type_"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._subclass_schema","name":"_subclass_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","type_"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_subclass_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_tuple_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","tuple_type"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._tuple_schema","name":"_tuple_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","tuple_type"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_tuple_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_type_alias_type_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._type_alias_type_schema","name":"_type_alias_type_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","obj"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema","typing_extensions.TypeAliasType"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_type_alias_type_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_type_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._type_schema","name":"_type_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_type_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_typed_dict_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","typed_dict_cls","origin"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._typed_dict_schema","name":"_typed_dict_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","typed_dict_cls","origin"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_typed_dict_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_types_namespace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._types_namespace","name":"_types_namespace","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_types_namespace of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.NamespacesTuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._types_namespace","name":"_types_namespace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_types_namespace of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.NamespacesTuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"_typevars_map":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._typevars_map","name":"_typevars_map","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["typing.TypeVar",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_union_is_subclass_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","union_type"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._union_is_subclass_schema","name":"_union_is_subclass_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","union_type"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_union_is_subclass_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_union_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","union_type"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._union_schema","name":"_union_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","union_type"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_union_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_unknown_type_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._unknown_type_schema","name":"_unknown_type_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","obj"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_unknown_type_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_unsubstituted_typevar_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","typevar"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._unsubstituted_typevar_schema","name":"_unsubstituted_typevar_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","typevar"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema","typing.TypeVar"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_unsubstituted_typevar_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_zoneinfo_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema._zoneinfo_schema","name":"_zoneinfo_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_zoneinfo_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"clean_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","schema"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema.clean_schema","name":"clean_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","schema"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"clean_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"defs":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._generate_schema.GenerateSchema.defs","name":"defs","setter_type":null,"type":"pydantic._internal._generate_schema._Definitions"}},"field_name_stack":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._generate_schema.GenerateSchema.field_name_stack","name":"field_name_stack","setter_type":null,"type":"pydantic._internal._generate_schema._FieldNameStack"}},"generate_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema.generate_schema","name":"generate_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","obj"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"generate_schema of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"match_type":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema.GenerateSchema.match_type","name":"match_type","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","obj"],"arg_types":["pydantic._internal._generate_schema.GenerateSchema",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"match_type of GenerateSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"model_type_stack":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._generate_schema.GenerateSchema.model_type_stack","name":"model_type_stack","setter_type":null,"type":"pydantic._internal._generate_schema._ModelTypeStack"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._generate_schema.GenerateSchema.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._generate_schema.GenerateSchema","values":[],"variance":0},"slots":["_config_wrapper_stack","_ns_resolver","_typevars_map","defs","field_name_stack","model_type_stack"],"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Generator":{".class":"SymbolTableNode","cross_ref":"typing.Generator","kind":"Gdef"},"GenericAlias":{".class":"SymbolTableNode","cross_ref":"types.GenericAlias","kind":"Gdef"},"GetCoreSchemaFunction":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic._internal._generate_schema.GetCoreSchemaFunction","line":128,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"pydantic.annotated_handlers.GetCoreSchemaHandler"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"GetCoreSchemaHandler":{".class":"SymbolTableNode","cross_ref":"pydantic.annotated_handlers.GetCoreSchemaHandler","kind":"Gdef"},"GetJsonSchemaFunction":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._schema_generation_shared.GetJsonSchemaFunction","kind":"Gdef"},"GetJsonSchemaHandler":{".class":"SymbolTableNode","cross_ref":"pydantic.annotated_handlers.GetJsonSchemaHandler","kind":"Gdef"},"IP_TYPES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic._internal._generate_schema.IP_TYPES","name":"IP_TYPES","setter_type":null,"type":{".class":"Instance","args":["builtins.type"],"extra_attrs":null,"type_ref":"builtins.list"}}},"IPv4Address":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv4Address","kind":"Gdef"},"IPv4Interface":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv4Interface","kind":"Gdef"},"IPv4Network":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv4Network","kind":"Gdef"},"IPv6Address":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv6Address","kind":"Gdef"},"IPv6Interface":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv6Interface","kind":"Gdef"},"IPv6Network":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv6Network","kind":"Gdef"},"ITERABLE_TYPES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic._internal._generate_schema.ITERABLE_TYPES","name":"ITERABLE_TYPES","setter_type":null,"type":{".class":"Instance","args":["builtins.type"],"extra_attrs":null,"type_ref":"builtins.list"}}},"InvalidSchemaError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.Exception"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._generate_schema.InvalidSchemaError","name":"InvalidSchemaError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._generate_schema.InvalidSchemaError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic._internal._generate_schema","mro":["pydantic._internal._generate_schema.InvalidSchemaError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._generate_schema.InvalidSchemaError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._generate_schema.InvalidSchemaError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef"},"Iterator":{".class":"SymbolTableNode","cross_ref":"typing.Iterator","kind":"Gdef"},"JsonDict":{".class":"SymbolTableNode","cross_ref":"pydantic.config.JsonDict","kind":"Gdef"},"JsonEncoder":{".class":"SymbolTableNode","cross_ref":"pydantic.config.JsonEncoder","kind":"Gdef"},"JsonEncoders":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic._internal._generate_schema.JsonEncoders","line":294,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.config.JsonEncoder"}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"JsonSchemaExtraCallable":{".class":"SymbolTableNode","cross_ref":"pydantic.config.JsonSchemaExtraCallable","kind":"Gdef"},"JsonSchemaValue":{".class":"SymbolTableNode","cross_ref":"pydantic.json_schema.JsonSchemaValue","kind":"Gdef"},"LIST_TYPES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic._internal._generate_schema.LIST_TYPES","name":"LIST_TYPES","setter_type":null,"type":{".class":"Instance","args":["builtins.type"],"extra_attrs":null,"type_ref":"builtins.list"}}},"LambdaType":{".class":"SymbolTableNode","cross_ref":"types.LambdaType","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"MAPPING_TYPES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._generate_schema.MAPPING_TYPES","name":"MAPPING_TYPES","setter_type":null,"type":{".class":"Instance","args":[{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"abc.ABCMeta","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing._KT","id":3771,"name":"_KT","namespace":"","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing._VT","id":3772,"name":"_VT","namespace":"","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"typing.Mapping"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing._KT","id":3771,"name":"_KT","namespace":"","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing._VT","id":3772,"name":"_VT","namespace":"","upper_bound":"builtins.object","values":[],"variance":0}]}],"extra_attrs":null,"type_ref":"builtins.list"}}},"MISSING":{".class":"SymbolTableNode","cross_ref":"pydantic_core.MISSING","kind":"Gdef"},"Mapping":{".class":"SymbolTableNode","cross_ref":"typing.Mapping","kind":"Gdef"},"MethodType":{".class":"SymbolTableNode","cross_ref":"types.MethodType","kind":"Gdef"},"MissingDefinitionError":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._schema_gather.MissingDefinitionError","kind":"Gdef"},"MockCoreSchema":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._mock_val_ser.MockCoreSchema","kind":"Gdef"},"ModelSerializerDecoratorInfo":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._decorators.ModelSerializerDecoratorInfo","kind":"Gdef"},"ModelValidatorDecoratorInfo":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._decorators.ModelValidatorDecoratorInfo","kind":"Gdef"},"ModifyCoreSchemaWrapHandler":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic._internal._generate_schema.ModifyCoreSchemaWrapHandler","line":127,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":"pydantic.annotated_handlers.GetCoreSchemaHandler"}},"MultiHostUrl":{".class":"SymbolTableNode","cross_ref":"pydantic_core._pydantic_core.MultiHostUrl","kind":"Gdef"},"NamespacesTuple":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._namespace_utils.NamespacesTuple","kind":"Gdef"},"NsResolver":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._namespace_utils.NsResolver","kind":"Gdef"},"PATH_TYPES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic._internal._generate_schema.PATH_TYPES","name":"PATH_TYPES","setter_type":null,"type":{".class":"Instance","args":["builtins.type"],"extra_attrs":null,"type_ref":"builtins.list"}}},"PATTERN_TYPES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic._internal._generate_schema.PATTERN_TYPES","name":"PATTERN_TYPES","setter_type":null,"type":{".class":"Instance","args":["builtins.type"],"extra_attrs":null,"type_ref":"builtins.list"}}},"Parameter":{".class":"SymbolTableNode","cross_ref":"inspect.Parameter","kind":"Gdef"},"ParametersCallback":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic._internal._generate_schema.ParametersCallback","line":129,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,null,null],"arg_types":["builtins.int","builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"skip"},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"PlainValidator":{".class":"SymbolTableNode","cross_ref":"pydantic.functional_validators.PlainValidator","kind":"Gdef"},"PydanticCustomError":{".class":"SymbolTableNode","cross_ref":"pydantic_core._pydantic_core.PydanticCustomError","kind":"Gdef"},"PydanticDeprecatedSince20":{".class":"SymbolTableNode","cross_ref":"pydantic.warnings.PydanticDeprecatedSince20","kind":"Gdef"},"PydanticRecursiveRef":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._forward_ref.PydanticRecursiveRef","kind":"Gdef"},"PydanticSchemaGenerationError":{".class":"SymbolTableNode","cross_ref":"pydantic.errors.PydanticSchemaGenerationError","kind":"Gdef"},"PydanticSerializationUnexpectedValue":{".class":"SymbolTableNode","cross_ref":"pydantic_core._pydantic_core.PydanticSerializationUnexpectedValue","kind":"Gdef"},"PydanticUndefined":{".class":"SymbolTableNode","cross_ref":"pydantic_core._pydantic_core.PydanticUndefined","kind":"Gdef"},"PydanticUndefinedAnnotation":{".class":"SymbolTableNode","cross_ref":"pydantic.errors.PydanticUndefinedAnnotation","kind":"Gdef"},"PydanticUserError":{".class":"SymbolTableNode","cross_ref":"pydantic.errors.PydanticUserError","kind":"Gdef"},"RootValidatorDecoratorInfo":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._decorators.RootValidatorDecoratorInfo","kind":"Gdef"},"SEQUENCE_TYPES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic._internal._generate_schema.SEQUENCE_TYPES","name":"SEQUENCE_TYPES","setter_type":null,"type":{".class":"Instance","args":["builtins.type"],"extra_attrs":null,"type_ref":"builtins.list"}}},"SET_TYPES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic._internal._generate_schema.SET_TYPES","name":"SET_TYPES","setter_type":null,"type":{".class":"Instance","args":["builtins.type"],"extra_attrs":null,"type_ref":"builtins.list"}}},"StandardDataclass":{".class":"SymbolTableNode","cross_ref":"_typeshed.DataclassInstance","kind":"Gdef"},"TUPLE_TYPES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic._internal._generate_schema.TUPLE_TYPES","name":"TUPLE_TYPES","setter_type":null,"type":{".class":"Instance","args":["builtins.type"],"extra_attrs":null,"type_ref":"builtins.list"}}},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"TYPE_TYPES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic._internal._generate_schema.TYPE_TYPES","name":"TYPE_TYPES","setter_type":null,"type":{".class":"Instance","args":["builtins.type"],"extra_attrs":null,"type_ref":"builtins.list"}}},"TypeAlias":{".class":"SymbolTableNode","cross_ref":"typing_extensions.TypeAlias","kind":"Gdef"},"TypeAliasType":{".class":"SymbolTableNode","cross_ref":"typing_extensions.TypeAliasType","kind":"Gdef"},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef"},"TypedDictExtraConfigWarning":{".class":"SymbolTableNode","cross_ref":"pydantic.warnings.TypedDictExtraConfigWarning","kind":"Gdef"},"UNSUPPORTED_STANDALONE_FIELDINFO_ATTRIBUTES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic._internal._generate_schema.UNSUPPORTED_STANDALONE_FIELDINFO_ATTRIBUTES","name":"UNSUPPORTED_STANDALONE_FIELDINFO_ATTRIBUTES","setter_type":null,"type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"builtins.list"}}},"UUID":{".class":"SymbolTableNode","cross_ref":"uuid.UUID","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"UnsupportedFieldAttributeWarning":{".class":"SymbolTableNode","cross_ref":"pydantic.warnings.UnsupportedFieldAttributeWarning","kind":"Gdef"},"Url":{".class":"SymbolTableNode","cross_ref":"pydantic_core._pydantic_core.Url","kind":"Gdef"},"VALIDATE_CALL_SUPPORTED_TYPES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._generate_schema.VALIDATE_CALL_SUPPORTED_TYPES","name":"VALIDATE_CALL_SUPPORTED_TYPES","setter_type":null,"type":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.AnnotationForm"}],"extra_attrs":null,"type_ref":"builtins.tuple"}}},"ValidateCallSupportedTypes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic._internal._generate_schema.ValidateCallSupportedTypes","line":164,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["types.FunctionType","types.FunctionType","types.MethodType",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"functools.partial"}],"uses_pep604_syntax":false}}},"ValidatorDecoratorInfo":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._decorators.ValidatorDecoratorInfo","kind":"Gdef"},"WrapValidator":{".class":"SymbolTableNode","cross_ref":"pydantic.functional_validators.WrapValidator","kind":"Gdef"},"ZoneInfo":{".class":"SymbolTableNode","cross_ref":"zoneinfo.ZoneInfo","kind":"Gdef"},"_Definitions":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._generate_schema._Definitions","name":"_Definitions","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._generate_schema._Definitions","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic._internal._generate_schema","mro":["pydantic._internal._generate_schema._Definitions","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema._Definitions.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._generate_schema._Definitions"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of _Definitions","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_definitions":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._generate_schema._Definitions._definitions","name":"_definitions","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_recursively_seen":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._generate_schema._Definitions._recursively_seen","name":"_recursively_seen","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"_resolve_definition":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","ref","definitions"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema._Definitions._resolve_definition","name":"_resolve_definition","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","ref","definitions"],"arg_types":["pydantic._internal._generate_schema._Definitions","builtins.str",{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_resolve_definition of _Definitions","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"create_definition_reference_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","schema"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema._Definitions.create_definition_reference_schema","name":"create_definition_reference_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","schema"],"arg_types":["pydantic._internal._generate_schema._Definitions",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"create_definition_reference_schema of _Definitions","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.DefinitionReferenceSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"finalize_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","schema"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema._Definitions.finalize_schema","name":"finalize_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","schema"],"arg_types":["pydantic._internal._generate_schema._Definitions",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"finalize_schema of _Definitions","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_schema_from_ref":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","ref"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema._Definitions.get_schema_from_ref","name":"get_schema_from_ref","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","ref"],"arg_types":["pydantic._internal._generate_schema._Definitions","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_schema_from_ref of _Definitions","ret_type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_schema_or_ref":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated","is_trivial_self"],"fullname":"pydantic._internal._generate_schema._Definitions.get_schema_or_ref","name":"get_schema_or_ref","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["pydantic._internal._generate_schema._Definitions",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_schema_or_ref of _Definitions","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.str",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.DefinitionReferenceSchema"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Generator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred"],"fullname":"pydantic._internal._generate_schema._Definitions.get_schema_or_ref","name":"get_schema_or_ref","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["pydantic._internal._generate_schema._Definitions",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_schema_or_ref of _Definitions","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.str",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.DefinitionReferenceSchema"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.DefinitionReferenceSchema"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"unpack_definitions":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","schema"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema._Definitions.unpack_definitions","name":"unpack_definitions","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","schema"],"arg_types":["pydantic._internal._generate_schema._Definitions",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.DefinitionsSchema"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unpack_definitions of _Definitions","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._generate_schema._Definitions.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._generate_schema._Definitions","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_FieldNameStack":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._generate_schema._FieldNameStack","name":"_FieldNameStack","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._generate_schema._FieldNameStack","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic._internal._generate_schema","mro":["pydantic._internal._generate_schema._FieldNameStack","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema._FieldNameStack.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._generate_schema._FieldNameStack"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of _FieldNameStack","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic._internal._generate_schema._FieldNameStack.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_stack":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic._internal._generate_schema._FieldNameStack._stack","name":"_stack","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"get":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema._FieldNameStack.get","name":"get","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._generate_schema._FieldNameStack"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get of _FieldNameStack","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"push":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","field_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated","is_trivial_self"],"fullname":"pydantic._internal._generate_schema._FieldNameStack.push","name":"push","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","field_name"],"arg_types":["pydantic._internal._generate_schema._FieldNameStack","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"push of _FieldNameStack","ret_type":{".class":"Instance","args":[{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Iterator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred"],"fullname":"pydantic._internal._generate_schema._FieldNameStack.push","name":"push","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","field_name"],"arg_types":["pydantic._internal._generate_schema._FieldNameStack","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"push of _FieldNameStack","ret_type":{".class":"Instance","args":[{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._generate_schema._FieldNameStack.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._generate_schema._FieldNameStack","values":[],"variance":0},"slots":["_stack"],"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_ModelTypeStack":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._generate_schema._ModelTypeStack","name":"_ModelTypeStack","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._generate_schema._ModelTypeStack","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic._internal._generate_schema","mro":["pydantic._internal._generate_schema._ModelTypeStack","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema._ModelTypeStack.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._generate_schema._ModelTypeStack"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of _ModelTypeStack","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic._internal._generate_schema._ModelTypeStack.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_stack":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic._internal._generate_schema._ModelTypeStack._stack","name":"_stack","setter_type":null,"type":{".class":"Instance","args":["builtins.type"],"extra_attrs":null,"type_ref":"builtins.list"}}},"get":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generate_schema._ModelTypeStack.get","name":"get","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._generate_schema._ModelTypeStack"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get of _ModelTypeStack","ret_type":{".class":"UnionType","items":["builtins.type",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"push":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","type_obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated","is_trivial_self"],"fullname":"pydantic._internal._generate_schema._ModelTypeStack.push","name":"push","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","type_obj"],"arg_types":["pydantic._internal._generate_schema._ModelTypeStack","builtins.type"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"push of _ModelTypeStack","ret_type":{".class":"Instance","args":[{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Iterator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred"],"fullname":"pydantic._internal._generate_schema._ModelTypeStack.push","name":"push","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","type_obj"],"arg_types":["pydantic._internal._generate_schema._ModelTypeStack","builtins.type"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"push of _ModelTypeStack","ret_type":{".class":"Instance","args":[{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._generate_schema._ModelTypeStack.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._generate_schema._ModelTypeStack","values":[],"variance":0},"slots":["_stack"],"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_ParameterKind":{".class":"SymbolTableNode","cross_ref":"inspect._ParameterKind","kind":"Gdef"},"_SUPPORTS_TYPEDDICT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._generate_schema._SUPPORTS_TYPEDDICT","name":"_SUPPORTS_TYPEDDICT","setter_type":null,"type":"builtins.bool"}},"_VALIDATOR_F_MATCH":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic._internal._generate_schema._VALIDATOR_F_MATCH","name":"_VALIDATOR_F_MATCH","setter_type":null,"type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.functional_validators.FieldValidatorModes"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"no-info"},{".class":"LiteralType","fallback":"builtins.str","value":"with-info"}],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"extra_attrs":null,"type_ref":"typing.Mapping"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._generate_schema.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._generate_schema.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._generate_schema.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._generate_schema.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._generate_schema.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._generate_schema.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_add_custom_serialization_from_json_encoders":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["json_encoders","tp","schema"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._generate_schema._add_custom_serialization_from_json_encoders","name":"_add_custom_serialization_from_json_encoders","original_first_arg":"json_encoders","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["json_encoders","tp","schema"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._generate_schema.JsonEncoders"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_add_custom_serialization_from_json_encoders","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"_convert_to_aliases":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["alias"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._generate_schema._convert_to_aliases","name":"_convert_to_aliases","original_first_arg":"alias","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["alias"],"arg_types":[{".class":"UnionType","items":["builtins.str","pydantic.aliases.AliasChoices","pydantic.aliases.AliasPath",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_convert_to_aliases","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str","builtins.int"],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":[{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str","builtins.int"],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_decorators":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._decorators","kind":"Gdef"},"_discriminated_union":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._discriminated_union","kind":"Gdef"},"_extract_get_pydantic_json_schema":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["tp"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._generate_schema._extract_get_pydantic_json_schema","name":"_extract_get_pydantic_json_schema","original_first_arg":"tp","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["tp"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_extract_get_pydantic_json_schema","ret_type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._schema_generation_shared.GetJsonSchemaFunction"},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_extract_json_schema_info_from_field_info":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["info"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._generate_schema._extract_json_schema_info_from_field_info","name":"_extract_json_schema_info_from_field_info","original_first_arg":"info","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["info"],"arg_types":[{".class":"UnionType","items":["pydantic.fields.FieldInfo","pydantic.fields.ComputedFieldInfo"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_extract_json_schema_info_from_field_info","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.config.JsonDict"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.config.JsonDict"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.config.JsonSchemaExtraCallable"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_inlining_behavior":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["def_ref"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._generate_schema._inlining_behavior","name":"_inlining_behavior","original_first_arg":"def_ref","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["def_ref"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.DefinitionReferenceSchema"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_inlining_behavior","ret_type":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"inline"},{".class":"LiteralType","fallback":"builtins.str","value":"keep"},{".class":"LiteralType","fallback":"builtins.str","value":"preserve_metadata"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_known_annotated_metadata":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._known_annotated_metadata","kind":"Gdef"},"_mode_to_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic._internal._generate_schema._mode_to_validator","name":"_mode_to_validator","setter_type":null,"type":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.functional_validators.FieldValidatorModes"},{".class":"UnionType","items":[{".class":"TypeType","item":"pydantic.functional_validators.BeforeValidator"},{".class":"TypeType","item":"pydantic.functional_validators.AfterValidator"},{".class":"TypeType","item":"pydantic.functional_validators.PlainValidator"},{".class":"TypeType","item":"pydantic.functional_validators.WrapValidator"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_repr":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._repr","kind":"Gdef"},"_typing_extra":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._typing_extra","kind":"Gdef"},"_validators_require_validate_default":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["validators"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._generate_schema._validators_require_validate_default","name":"_validators_require_validate_default","original_first_arg":"validators","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["validators"],"arg_types":[{".class":"Instance","args":[{".class":"Instance","args":["pydantic._internal._decorators.ValidatorDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_validators_require_validate_default","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"apply_each_item_validators":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["schema","each_item_validators"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._generate_schema.apply_each_item_validators","name":"apply_each_item_validators","original_first_arg":"schema","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["schema","each_item_validators"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},{".class":"Instance","args":[{".class":"Instance","args":["pydantic._internal._decorators.ValidatorDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"apply_each_item_validators","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"apply_model_validators":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["schema","validators","mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._generate_schema.apply_model_validators","name":"apply_model_validators","original_first_arg":"schema","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["schema","validators","mode"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},{".class":"Instance","args":[{".class":"Instance","args":["pydantic._internal._decorators.ModelValidatorDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"inner"},{".class":"LiteralType","fallback":"builtins.str","value":"outer"},{".class":"LiteralType","fallback":"builtins.str","value":"all"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"apply_model_validators","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"apply_validators":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["schema","validators"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._generate_schema.apply_validators","name":"apply_validators","original_first_arg":"schema","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["schema","validators"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"Instance","args":["pydantic._internal._decorators.RootValidatorDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"Instance","args":[{".class":"Instance","args":["pydantic._internal._decorators.ValidatorDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"Instance","args":[{".class":"Instance","args":["pydantic._internal._decorators.FieldValidatorDecoratorInfo"],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"apply_validators","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"attrgetter":{".class":"SymbolTableNode","cross_ref":"operator.attrgetter","kind":"Gdef"},"cast":{".class":"SymbolTableNode","cross_ref":"typing.cast","kind":"Gdef"},"chain":{".class":"SymbolTableNode","cross_ref":"itertools.chain","kind":"Gdef"},"check_decorator_fields_exist":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["decorators","fields"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._generate_schema.check_decorator_fields_exist","name":"check_decorator_fields_exist","original_first_arg":"decorators","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["decorators","fields"],"arg_types":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._generate_schema.AnyFieldDecorator"}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"check_decorator_fields_exist","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"check_validator_fields_against_field_name":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["info","field"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._generate_schema.check_validator_fields_against_field_name","name":"check_validator_fields_against_field_name","original_first_arg":"info","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["info","field"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._generate_schema.FieldDecoratorInfo"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"check_validator_fields_against_field_name","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"collect_dataclass_fields":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._fields.collect_dataclass_fields","kind":"Gdef"},"collections":{".class":"SymbolTableNode","cross_ref":"collections","kind":"Gdef"},"contextmanager":{".class":"SymbolTableNode","cross_ref":"contextlib.contextmanager","kind":"Gdef"},"copy":{".class":"SymbolTableNode","cross_ref":"copy.copy","kind":"Gdef"},"core_schema":{".class":"SymbolTableNode","cross_ref":"pydantic_core.core_schema","kind":"Gdef"},"dataclasses":{".class":"SymbolTableNode","cross_ref":"dataclasses","kind":"Gdef"},"datetime":{".class":"SymbolTableNode","cross_ref":"datetime","kind":"Gdef"},"extract_docstrings_from_cls":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._docs_extraction.extract_docstrings_from_cls","kind":"Gdef"},"filter_field_decorator_info_by_field":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["validator_functions","field"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._generate_schema.filter_field_decorator_info_by_field","name":"filter_field_decorator_info_by_field","original_first_arg":"validator_functions","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["validator_functions","field"],"arg_types":[{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._generate_schema.FieldDecoratorInfoType","id":-1,"name":"FieldDecoratorInfoType","namespace":"pydantic._internal._generate_schema.filter_field_decorator_info_by_field","upper_bound":{".class":"UnionType","items":["pydantic._internal._decorators.ValidatorDecoratorInfo","pydantic._internal._decorators.FieldValidatorDecoratorInfo","pydantic._internal._decorators.FieldSerializerDecoratorInfo"],"uses_pep604_syntax":false},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"filter_field_decorator_info_by_field","ret_type":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._generate_schema.FieldDecoratorInfoType","id":-1,"name":"FieldDecoratorInfoType","namespace":"pydantic._internal._generate_schema.filter_field_decorator_info_by_field","upper_bound":{".class":"UnionType","items":["pydantic._internal._decorators.ValidatorDecoratorInfo","pydantic._internal._decorators.FieldValidatorDecoratorInfo","pydantic._internal._decorators.FieldSerializerDecoratorInfo"],"uses_pep604_syntax":false},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"pydantic._internal._decorators.Decorator"}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._generate_schema.FieldDecoratorInfoType","id":-1,"name":"FieldDecoratorInfoType","namespace":"pydantic._internal._generate_schema.filter_field_decorator_info_by_field","upper_bound":{".class":"UnionType","items":["pydantic._internal._decorators.ValidatorDecoratorInfo","pydantic._internal._decorators.FieldValidatorDecoratorInfo","pydantic._internal._decorators.FieldSerializerDecoratorInfo"],"uses_pep604_syntax":false},"values":[],"variance":0}]}}},"gather_schemas_for_cleaning":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._schema_gather.gather_schemas_for_cleaning","kind":"Gdef"},"get_args":{".class":"SymbolTableNode","cross_ref":"typing_extensions.get_args","kind":"Gdef"},"get_attribute_from_bases":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._decorators.get_attribute_from_bases","kind":"Gdef"},"get_literal_values":{".class":"SymbolTableNode","cross_ref":"typing_inspection.introspection.get_literal_values","kind":"Gdef"},"get_origin":{".class":"SymbolTableNode","cross_ref":"typing_extensions.get_origin","kind":"Gdef"},"get_ref":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._core_utils.get_ref","kind":"Gdef"},"get_standard_typevars_map":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._generics.get_standard_typevars_map","kind":"Gdef"},"get_type_ref":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._core_utils.get_type_ref","kind":"Gdef"},"import_cached_base_model":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._import_utils.import_cached_base_model","kind":"Gdef"},"import_cached_field_info":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._import_utils.import_cached_field_info","kind":"Gdef"},"inspect":{".class":"SymbolTableNode","cross_ref":"inspect","kind":"Gdef"},"inspect_field_serializer":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._decorators.inspect_field_serializer","kind":"Gdef"},"inspect_model_serializer":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._decorators.inspect_model_serializer","kind":"Gdef"},"inspect_validator":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._decorators.inspect_validator","kind":"Gdef"},"is_list_like_schema_with_items_schema":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._core_utils.is_list_like_schema_with_items_schema","kind":"Gdef"},"is_typeddict":{".class":"SymbolTableNode","cross_ref":"typing_extensions.is_typeddict","kind":"Gdef"},"is_union_origin":{".class":"SymbolTableNode","cross_ref":"typing_inspection.introspection.is_union_origin","kind":"Gdef"},"lenient_issubclass":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._utils.lenient_issubclass","kind":"Gdef"},"os":{".class":"SymbolTableNode","cross_ref":"os","kind":"Gdef"},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef"},"partial":{".class":"SymbolTableNode","cross_ref":"functools.partial","kind":"Gdef"},"pathlib":{".class":"SymbolTableNode","cross_ref":"pathlib","kind":"Gdef"},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef"},"rebuild_dataclass_fields":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._fields.rebuild_dataclass_fields","kind":"Gdef"},"rebuild_model_fields":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._fields.rebuild_model_fields","kind":"Gdef"},"replace_types":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._generics.replace_types","kind":"Gdef"},"resolve_original_schema":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["schema","definitions"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._generate_schema.resolve_original_schema","name":"resolve_original_schema","original_first_arg":"schema","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["schema","definitions"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"pydantic._internal._generate_schema._Definitions"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"resolve_original_schema","ret_type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"signature":{".class":"SymbolTableNode","cross_ref":"inspect.signature","kind":"Gdef"},"smart_deepcopy":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._utils.smart_deepcopy","kind":"Gdef"},"sys":{".class":"SymbolTableNode","cross_ref":"sys","kind":"Gdef"},"takes_validated_data_argument":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._fields.takes_validated_data_argument","kind":"Gdef"},"to_jsonable_python":{".class":"SymbolTableNode","cross_ref":"pydantic_core._pydantic_core.to_jsonable_python","kind":"Gdef"},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef"},"typing_extensions":{".class":"SymbolTableNode","cross_ref":"typing_extensions","kind":"Gdef"},"typing_objects":{".class":"SymbolTableNode","cross_ref":"typing_inspection.typing_objects","kind":"Gdef"},"update_core_metadata":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._core_metadata.update_core_metadata","kind":"Gdef"},"update_field_from_config":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._fields.update_field_from_config","kind":"Gdef"},"version_short":{".class":"SymbolTableNode","cross_ref":"pydantic.version.version_short","kind":"Gdef"},"warnings":{".class":"SymbolTableNode","cross_ref":"warnings","kind":"Gdef"},"wrap_default":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["field_info","schema"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._generate_schema.wrap_default","name":"wrap_default","original_first_arg":"field_info","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["field_info","schema"],"arg_types":["pydantic.fields.FieldInfo",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"wrap_default","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_generate_schema.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_generate_schema.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_generate_schema.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..7a8ae93cf4a17f97b52bc854900feecf09859521 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_generate_schema.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[71,71,71,71,71,72,73,74,93,94,101,102,103,104,105,106,107,108,114,468,559,5,43,55,56,58,59,60,61,62,63,64,65,71,111,112,113,934,1849,3,5,6,7,8,9,10,11,12,13,14,16,17,18,19,20,21,23,24,25,26,39,40,42,43,55,1,1,1,1,1,1],"dep_prios":[5,10,10,10,10,5,5,5,5,5,5,5,5,5,5,5,5,5,25,20,20,5,10,10,5,5,5,5,5,5,5,5,5,20,25,25,25,20,20,5,20,10,10,5,10,10,10,10,5,10,5,5,5,5,5,5,5,5,5,5,5,5,5,5,20,5,30,30,30,30,30],"dependencies":["pydantic._internal._decorators","pydantic._internal._discriminated_union","pydantic._internal._known_annotated_metadata","pydantic._internal._repr","pydantic._internal._typing_extra","pydantic._internal._config","pydantic._internal._core_metadata","pydantic._internal._core_utils","pydantic._internal._docs_extraction","pydantic._internal._fields","pydantic._internal._forward_ref","pydantic._internal._generics","pydantic._internal._import_utils","pydantic._internal._mock_val_ser","pydantic._internal._namespace_utils","pydantic._internal._schema_gather","pydantic._internal._schema_generation_shared","pydantic._internal._utils","pydantic._internal._dataclasses","pydantic._internal._validators","pydantic._internal._serializers","collections.abc","pydantic_core.core_schema","typing_inspection.typing_objects","typing_inspection.introspection","pydantic.aliases","pydantic.annotated_handlers","pydantic.config","pydantic.errors","pydantic.functional_validators","pydantic.json_schema","pydantic.version","pydantic.warnings","pydantic._internal","pydantic.fields","pydantic.main","pydantic.types","pydantic.v1","pydantic.dataclasses","__future__","collections","dataclasses","datetime","inspect","os","pathlib","re","sys","typing","warnings","contextlib","copy","decimal","enum","fractions","functools","ipaddress","itertools","operator","types","uuid","zoneinfo","typing_extensions","pydantic_core","typing_inspection","builtins","_frozen_importlib","_typeshed","abc","pydantic._internal._model_construction","pydantic_core._pydantic_core"],"hash":"a3f60fa819dbc22baa780de0f3ba2163fb633a3b","id":"pydantic._internal._generate_schema","ignore_all":true,"interface_hash":"eacfc54d85c7fbd74fde102660ae37935abdb13b","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_generate_schema.py","plugin_data":null,"size":132665,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_generics.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_generics.data.json new file mode 100644 index 0000000000000000000000000000000000000000..f9edffc278d5b33d088de92765fdeab915f4e752 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_generics.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic._internal._generics","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Annotated":{".class":"SymbolTableNode","cross_ref":"typing.Annotated","kind":"Gdef"},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseModel":{".class":"SymbolTableNode","cross_ref":"pydantic.main.BaseModel","kind":"Gdef"},"ChainMap":{".class":"SymbolTableNode","cross_ref":"collections.ChainMap","kind":"Gdef"},"ContextVar":{".class":"SymbolTableNode","cross_ref":"_contextvars.ContextVar","kind":"Gdef"},"DeepChainMap":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._generics.KT","id":1,"name":"KT","namespace":"pydantic._internal._generics.DeepChainMap","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._generics.VT","id":2,"name":"VT","namespace":"pydantic._internal._generics.DeepChainMap","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"collections.ChainMap"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._generics.DeepChainMap","name":"DeepChainMap","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._generics.KT","id":1,"name":"KT","namespace":"pydantic._internal._generics.DeepChainMap","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._generics.VT","id":2,"name":"VT","namespace":"pydantic._internal._generics.DeepChainMap","upper_bound":"builtins.object","values":[],"variance":0}]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._generics.DeepChainMap","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic._internal._generics","mro":["pydantic._internal._generics.DeepChainMap","collections.ChainMap","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._generics.DeepChainMap.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._generics.KT","id":1,"name":"KT","namespace":"pydantic._internal._generics.DeepChainMap","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._generics.VT","id":2,"name":"VT","namespace":"pydantic._internal._generics.DeepChainMap","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"pydantic._internal._generics.DeepChainMap"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["KT","VT"],"typeddict_type":null}},"DictValues":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic._internal._generics.DictValues","name":"DictValues","setter_type":null,"type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}}},"GenericTypesCache":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic._internal._generics.GenericTypesCache","line":58,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._generics.GenericTypesCacheKey"},{".class":"TypeType","item":"pydantic.main.BaseModel"}],"extra_attrs":null,"type_ref":"weakref.WeakValueDictionary"}}},"GenericTypesCacheKey":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic._internal._generics.GenericTypesCacheKey","line":29,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"Iterator":{".class":"SymbolTableNode","cross_ref":"typing.Iterator","kind":"Gdef"},"KT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._generics.KT","name":"KT","upper_bound":"builtins.object","values":[],"variance":0}},"LimitedDict":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._generics.KT","id":1,"name":"KT","namespace":"pydantic._internal._generics.LimitedDict","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._generics.VT","id":2,"name":"VT","namespace":"pydantic._internal._generics.LimitedDict","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.dict"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._generics.LimitedDict","name":"LimitedDict","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._generics.KT","id":1,"name":"KT","namespace":"pydantic._internal._generics.LimitedDict","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._generics.VT","id":2,"name":"VT","namespace":"pydantic._internal._generics.LimitedDict","upper_bound":"builtins.object","values":[],"variance":0}]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._generics.LimitedDict","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic._internal._generics","mro":["pydantic._internal._generics.LimitedDict","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","size_limit"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generics.LimitedDict.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","size_limit"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._generics.KT","id":1,"name":"KT","namespace":"pydantic._internal._generics.LimitedDict","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._generics.VT","id":2,"name":"VT","namespace":"pydantic._internal._generics.LimitedDict","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"pydantic._internal._generics.LimitedDict"},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of LimitedDict","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__setitem__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":[null,null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._generics.LimitedDict.__setitem__","name":"__setitem__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._generics.KT","id":1,"name":"KT","namespace":"pydantic._internal._generics.LimitedDict","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._generics.VT","id":2,"name":"VT","namespace":"pydantic._internal._generics.LimitedDict","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"pydantic._internal._generics.LimitedDict"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._generics.KT","id":1,"name":"KT","namespace":"pydantic._internal._generics.LimitedDict","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._generics.VT","id":2,"name":"VT","namespace":"pydantic._internal._generics.LimitedDict","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__setitem__ of LimitedDict","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"size_limit":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._generics.LimitedDict.size_limit","name":"size_limit","setter_type":null,"type":"builtins.int"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._generics.LimitedDict.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._generics.KT","id":1,"name":"KT","namespace":"pydantic._internal._generics.LimitedDict","upper_bound":"builtins.object","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._generics.VT","id":2,"name":"VT","namespace":"pydantic._internal._generics.LimitedDict","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"pydantic._internal._generics.LimitedDict"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["KT","VT"],"typeddict_type":null}},"Mapping":{".class":"SymbolTableNode","cross_ref":"typing.Mapping","kind":"Gdef"},"PydanticGenericMetadata":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._generics.PydanticGenericMetadata","name":"PydanticGenericMetadata","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._generics.PydanticGenericMetadata","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic._internal._generics","mro":["pydantic._internal._generics.PydanticGenericMetadata","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["origin",{".class":"UnionType","items":[{".class":"TypeType","item":"pydantic.main.BaseModel"},{".class":"NoneType"}],"uses_pep604_syntax":true}],["args",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}],["parameters",{".class":"Instance","args":["typing.TypeVar"],"extra_attrs":null,"type_ref":"builtins.tuple"}]],"readonly_keys":[],"required_keys":["args","origin","parameters"]}}},"PydanticRecursiveRef":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._forward_ref.PydanticRecursiveRef","kind":"Gdef"},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef"},"TypedDict":{".class":"SymbolTableNode","cross_ref":"typing.TypedDict","kind":"Gdef"},"VT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._generics.VT","name":"VT","upper_bound":"builtins.object","values":[],"variance":0}},"WeakValueDictionary":{".class":"SymbolTableNode","cross_ref":"weakref.WeakValueDictionary","kind":"Gdef"},"_GENERIC_TYPES_CACHE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic._internal._generics._GENERIC_TYPES_CACHE","name":"_GENERIC_TYPES_CACHE","setter_type":null,"type":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._generics.GenericTypesCache"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"_contextvars.ContextVar"}}},"_LIMITED_DICT_SIZE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._generics._LIMITED_DICT_SIZE","name":"_LIMITED_DICT_SIZE","setter_type":null,"type":"builtins.int"}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._generics.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._generics.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._generics.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._generics.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._generics.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._generics.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_early_cache_key":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","typevar_values"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._generics._early_cache_key","name":"_early_cache_key","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","typevar_values"],"arg_types":[{".class":"TypeType","item":"pydantic.main.BaseModel"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_early_cache_key","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._generics.GenericTypesCacheKey"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_generic_recursion_cache":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic._internal._generics._generic_recursion_cache","name":"_generic_recursion_cache","setter_type":null,"type":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"_contextvars.ContextVar"}}},"_get_caller_frame_info":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1],"arg_names":["depth"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._generics._get_caller_frame_info","name":"_get_caller_frame_info","original_first_arg":"depth","type":{".class":"CallableType","arg_kinds":[1],"arg_names":["depth"],"arg_types":["builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_caller_frame_info","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_late_cache_key":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["origin","args","typevar_values"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._generics._late_cache_key","name":"_late_cache_key","original_first_arg":"origin","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["origin","args","typevar_values"],"arg_types":[{".class":"TypeType","item":"pydantic.main.BaseModel"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_late_cache_key","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._generics.GenericTypesCacheKey"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_typing_extra":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._typing_extra","kind":"Gdef"},"_union_orderings_key":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["typevar_values"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._generics._union_orderings_key","name":"_union_orderings_key","original_first_arg":"typevar_values","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["typevar_values"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_union_orderings_key","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"all_identical":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._utils.all_identical","kind":"Gdef"},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"cast":{".class":"SymbolTableNode","cross_ref":"typing.cast","kind":"Gdef"},"contextmanager":{".class":"SymbolTableNode","cross_ref":"contextlib.contextmanager","kind":"Gdef"},"create_generic_submodel":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["model_name","origin","args","params"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._generics.create_generic_submodel","name":"create_generic_submodel","original_first_arg":"model_name","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["model_name","origin","args","params"],"arg_types":["builtins.str",{".class":"TypeType","item":"pydantic.main.BaseModel"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"create_generic_submodel","ret_type":{".class":"TypeType","item":"pydantic.main.BaseModel"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"generic_recursion_self_type":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["origin","args"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated"],"fullname":"pydantic._internal._generics.generic_recursion_self_type","name":"generic_recursion_self_type","original_first_arg":"origin","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["origin","args"],"arg_types":[{".class":"TypeType","item":"pydantic.main.BaseModel"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"generic_recursion_self_type","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["pydantic._internal._forward_ref.PydanticRecursiveRef",{".class":"NoneType"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"typing.Iterator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._generics.generic_recursion_self_type","name":"generic_recursion_self_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["origin","args"],"arg_types":[{".class":"TypeType","item":"pydantic.main.BaseModel"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"generic_recursion_self_type","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["pydantic._internal._forward_ref.PydanticRecursiveRef",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"get_args":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._generics.get_args","name":"get_args","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_args","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_cached_generic_type_early":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["parent","typevar_values"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._generics.get_cached_generic_type_early","name":"get_cached_generic_type_early","original_first_arg":"parent","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["parent","typevar_values"],"arg_types":[{".class":"TypeType","item":"pydantic.main.BaseModel"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_cached_generic_type_early","ret_type":{".class":"UnionType","items":[{".class":"TypeType","item":"pydantic.main.BaseModel"},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_cached_generic_type_late":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["parent","typevar_values","origin","args"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._generics.get_cached_generic_type_late","name":"get_cached_generic_type_late","original_first_arg":"parent","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["parent","typevar_values","origin","args"],"arg_types":[{".class":"TypeType","item":"pydantic.main.BaseModel"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeType","item":"pydantic.main.BaseModel"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_cached_generic_type_late","ret_type":{".class":"UnionType","items":[{".class":"TypeType","item":"pydantic.main.BaseModel"},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_model_typevars_map":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._generics.get_model_typevars_map","name":"get_model_typevars_map","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.main.BaseModel"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_model_typevars_map","ret_type":{".class":"Instance","args":["typing.TypeVar",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_origin":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._generics.get_origin","name":"get_origin","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_origin","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_standard_typevars_map":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._generics.get_standard_typevars_map","name":"get_standard_typevars_map","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_standard_typevars_map","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["typing.TypeVar",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_type_ref":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._core_utils.get_type_ref","kind":"Gdef"},"is_model_class":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._utils.is_model_class","kind":"Gdef"},"is_union_origin":{".class":"SymbolTableNode","cross_ref":"typing_inspection.introspection.is_union_origin","kind":"Gdef"},"iter_contained_typevars":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._generics.iter_contained_typevars","name":"iter_contained_typevars","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"iter_contained_typevars","ret_type":{".class":"Instance","args":["typing.TypeVar"],"extra_attrs":null,"type_ref":"typing.Iterator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"map_generic_model_arguments":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","args"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._generics.map_generic_model_arguments","name":"map_generic_model_arguments","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","args"],"arg_types":[{".class":"TypeType","item":"pydantic.main.BaseModel"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"map_generic_model_arguments","ret_type":{".class":"Instance","args":["typing.TypeVar",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"operator":{".class":"SymbolTableNode","cross_ref":"operator","kind":"Gdef"},"prepare_class":{".class":"SymbolTableNode","cross_ref":"types.prepare_class","kind":"Gdef"},"recursively_defined_type_refs":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._generics.recursively_defined_type_refs","name":"recursively_defined_type_refs","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"recursively_defined_type_refs","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"reduce":{".class":"SymbolTableNode","cross_ref":"functools.reduce","kind":"Gdef"},"replace_types":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["type_","type_map"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._generics.replace_types","name":"replace_types","original_first_arg":"type_","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["type_","type_map"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"Instance","args":["typing.TypeVar",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"replace_types","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"set_cached_generic_type":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1],"arg_names":["parent","typevar_values","type_","origin","args"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._generics.set_cached_generic_type","name":"set_cached_generic_type","original_first_arg":"parent","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1],"arg_names":["parent","typevar_values","type_","origin","args"],"arg_types":[{".class":"TypeType","item":"pydantic.main.BaseModel"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"TypeType","item":"pydantic.main.BaseModel"},{".class":"UnionType","items":[{".class":"TypeType","item":"pydantic.main.BaseModel"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"set_cached_generic_type","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"sys":{".class":"SymbolTableNode","cross_ref":"sys","kind":"Gdef"},"types":{".class":"SymbolTableNode","cross_ref":"types","kind":"Gdef"},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef"},"typing_extensions":{".class":"SymbolTableNode","cross_ref":"typing_extensions","kind":"Gdef"},"typing_objects":{".class":"SymbolTableNode","cross_ref":"typing_inspection.typing_objects","kind":"Gdef"},"zip_longest":{".class":"SymbolTableNode","cross_ref":"itertools.zip_longest","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_generics.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_generics.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_generics.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..5b12d8d391e6d36e3c0572c30b45584dcf2c1948 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_generics.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[21,22,23,24,8,18,19,21,27,1,3,4,5,6,7,9,10,11,12,15,17,18,1,1,1,1,1,1,1],"dep_prios":[10,5,5,5,5,10,5,20,25,5,10,10,5,5,5,5,5,5,5,5,10,20,5,30,30,30,30,30,30],"dependencies":["pydantic._internal._typing_extra","pydantic._internal._core_utils","pydantic._internal._forward_ref","pydantic._internal._utils","collections.abc","typing_inspection.typing_objects","typing_inspection.introspection","pydantic._internal","pydantic.main","__future__","operator","sys","types","typing","collections","contextlib","contextvars","functools","itertools","weakref","typing_extensions","typing_inspection","builtins","_collections_abc","_contextvars","_frozen_importlib","_typeshed","abc","pydantic._internal._model_construction"],"hash":"cbd00803410f33e500ea11f0d42b4e727625bbc7","id":"pydantic._internal._generics","ignore_all":true,"interface_hash":"eeb9d988c89d00fd15f97024049afb1c0fea367e","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_generics.py","plugin_data":null,"size":23822,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_import_utils.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_import_utils.data.json new file mode 100644 index 0000000000000000000000000000000000000000..8f1f2a62d943ced59f14afbd76bb4143f9fa8834 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_import_utils.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic._internal._import_utils","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","BaseModel":{".class":"SymbolTableNode","cross_ref":"pydantic.main.BaseModel","kind":"Gdef"},"FieldInfo":{".class":"SymbolTableNode","cross_ref":"pydantic.fields.FieldInfo","kind":"Gdef"},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._import_utils.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._import_utils.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._import_utils.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._import_utils.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._import_utils.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._import_utils.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"cache":{".class":"SymbolTableNode","cross_ref":"functools.cache","kind":"Gdef"},"import_cached_base_model":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated"],"fullname":"pydantic._internal._import_utils.import_cached_base_model","name":"import_cached_base_model","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"import_cached_base_model","ret_type":{".class":"TypeType","item":"pydantic.main.BaseModel"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._import_utils.import_cached_base_model","name":"import_cached_base_model","setter_type":null,"type":{".class":"Instance","args":[{".class":"TypeType","item":"pydantic.main.BaseModel"}],"extra_attrs":null,"type_ref":"functools._lru_cache_wrapper"}}}},"import_cached_field_info":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated"],"fullname":"pydantic._internal._import_utils.import_cached_field_info","name":"import_cached_field_info","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"import_cached_field_info","ret_type":{".class":"TypeType","item":"pydantic.fields.FieldInfo"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._import_utils.import_cached_field_info","name":"import_cached_field_info","setter_type":null,"type":{".class":"Instance","args":[{".class":"TypeType","item":"pydantic.fields.FieldInfo"}],"extra_attrs":null,"type_ref":"functools._lru_cache_wrapper"}}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_import_utils.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_import_utils.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_import_utils.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..32b7ba61f794d5311ac2ff6df89119717774e7b0 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_import_utils.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[6,1,2,5,1,1,1,1,1,1],"dep_prios":[25,5,5,25,5,30,30,30,30,30],"dependencies":["pydantic.fields","functools","typing","pydantic","builtins","_frozen_importlib","abc","pydantic._internal._model_construction","pydantic._internal._repr","pydantic.main"],"hash":"1ff82dc6c6014893c2992994f8b7aa9c18ce8069","id":"pydantic._internal._import_utils","ignore_all":true,"interface_hash":"d501ac9f867f9fe2deb5a9cae79c53afe8b04941","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_import_utils.py","plugin_data":null,"size":402,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_internal_dataclass.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_internal_dataclass.data.json new file mode 100644 index 0000000000000000000000000000000000000000..abee39d0afb386d2d20c7a687ebff39256534caa --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_internal_dataclass.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic._internal._internal_dataclass","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._internal_dataclass.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._internal_dataclass.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._internal_dataclass.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._internal_dataclass.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._internal_dataclass.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._internal_dataclass.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"slots_true":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","invalid_partial_type","has_explicit_value"],"fullname":"pydantic._internal._internal_dataclass.slots_true","name":"slots_true","setter_type":null,"type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"sys":{".class":"SymbolTableNode","cross_ref":"sys","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_internal_dataclass.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_internal_dataclass.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_internal_dataclass.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..685e2f8ac7250125ebaffc9bca902827f89456ca --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_internal_dataclass.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106713,"dep_lines":[1,1,1,1,1,1],"dep_prios":[10,5,30,30,30,30],"dependencies":["sys","builtins","_frozen_importlib","_typeshed","abc","typing"],"hash":"7706ce2fe440d3136b2bcacc2f20eab4301b09ab","id":"pydantic._internal._internal_dataclass","ignore_all":true,"interface_hash":"7155b5b3cc279bfad82aafac40938e2a25cd9d65","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_internal_dataclass.py","plugin_data":null,"size":144,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_known_annotated_metadata.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_known_annotated_metadata.data.json new file mode 100644 index 0000000000000000000000000000000000000000..23d2c58a954f106e14d2e6b9fef78c4d42a4e7eb --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_known_annotated_metadata.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic._internal._known_annotated_metadata","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","ALLOW_INF_NAN":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._known_annotated_metadata.ALLOW_INF_NAN","name":"ALLOW_INF_NAN","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BOOL_CONSTRAINTS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._known_annotated_metadata.BOOL_CONSTRAINTS","name":"BOOL_CONSTRAINTS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"BYTES_CONSTRAINTS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._known_annotated_metadata.BYTES_CONSTRAINTS","name":"BYTES_CONSTRAINTS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"COMPLEX_CONSTRAINTS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._known_annotated_metadata.COMPLEX_CONSTRAINTS","name":"COMPLEX_CONSTRAINTS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"CONSTRAINTS_TO_ALLOWED_SCHEMAS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic._internal._known_annotated_metadata.CONSTRAINTS_TO_ALLOWED_SCHEMAS","name":"CONSTRAINTS_TO_ALLOWED_SCHEMAS","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"CoreSchema":{".class":"SymbolTableNode","cross_ref":"pydantic_core.core_schema.CoreSchema","kind":"Gdef"},"DATE_TIME_CONSTRAINTS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._known_annotated_metadata.DATE_TIME_CONSTRAINTS","name":"DATE_TIME_CONSTRAINTS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"DECIMAL_CONSTRAINTS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._known_annotated_metadata.DECIMAL_CONSTRAINTS","name":"DECIMAL_CONSTRAINTS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"DICT_CONSTRAINTS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._known_annotated_metadata.DICT_CONSTRAINTS","name":"DICT_CONSTRAINTS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"ENUM_CONSTRAINTS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._known_annotated_metadata.ENUM_CONSTRAINTS","name":"ENUM_CONSTRAINTS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"FAIL_FAST":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._known_annotated_metadata.FAIL_FAST","name":"FAIL_FAST","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"FLOAT_CONSTRAINTS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._known_annotated_metadata.FLOAT_CONSTRAINTS","name":"FLOAT_CONSTRAINTS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"GENERATOR_CONSTRAINTS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._known_annotated_metadata.GENERATOR_CONSTRAINTS","name":"GENERATOR_CONSTRAINTS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"INEQUALITY":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._known_annotated_metadata.INEQUALITY","name":"INEQUALITY","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"INT_CONSTRAINTS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._known_annotated_metadata.INT_CONSTRAINTS","name":"INT_CONSTRAINTS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef"},"LAX_OR_STRICT_CONSTRAINTS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._known_annotated_metadata.LAX_OR_STRICT_CONSTRAINTS","name":"LAX_OR_STRICT_CONSTRAINTS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"LENGTH_CONSTRAINTS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._known_annotated_metadata.LENGTH_CONSTRAINTS","name":"LENGTH_CONSTRAINTS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"LIST_CONSTRAINTS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._known_annotated_metadata.LIST_CONSTRAINTS","name":"LIST_CONSTRAINTS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"NUMERIC_CONSTRAINTS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._known_annotated_metadata.NUMERIC_CONSTRAINTS","name":"NUMERIC_CONSTRAINTS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"NUMERIC_SCHEMA_TYPES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._known_annotated_metadata.NUMERIC_SCHEMA_TYPES","name":"NUMERIC_SCHEMA_TYPES","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"PydanticCustomError":{".class":"SymbolTableNode","cross_ref":"pydantic_core._pydantic_core.PydanticCustomError","kind":"Gdef"},"PydanticMetadata":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._fields.PydanticMetadata","kind":"Gdef"},"SEQUENCE_CONSTRAINTS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._known_annotated_metadata.SEQUENCE_CONSTRAINTS","name":"SEQUENCE_CONSTRAINTS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"SEQUENCE_SCHEMA_TYPES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._known_annotated_metadata.SEQUENCE_SCHEMA_TYPES","name":"SEQUENCE_SCHEMA_TYPES","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"SET_CONSTRAINTS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._known_annotated_metadata.SET_CONSTRAINTS","name":"SET_CONSTRAINTS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"STRICT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._known_annotated_metadata.STRICT","name":"STRICT","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"STR_CONSTRAINTS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._known_annotated_metadata.STR_CONSTRAINTS","name":"STR_CONSTRAINTS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"TEXT_SCHEMA_TYPES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._known_annotated_metadata.TEXT_SCHEMA_TYPES","name":"TEXT_SCHEMA_TYPES","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"TIMEDELTA_CONSTRAINTS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._known_annotated_metadata.TIMEDELTA_CONSTRAINTS","name":"TIMEDELTA_CONSTRAINTS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"TIME_CONSTRAINTS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._known_annotated_metadata.TIME_CONSTRAINTS","name":"TIME_CONSTRAINTS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"TUPLE_CONSTRAINTS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._known_annotated_metadata.TUPLE_CONSTRAINTS","name":"TUPLE_CONSTRAINTS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"UNION_CONSTRAINTS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._known_annotated_metadata.UNION_CONSTRAINTS","name":"UNION_CONSTRAINTS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"URL_CONSTRAINTS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._known_annotated_metadata.URL_CONSTRAINTS","name":"URL_CONSTRAINTS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"UUID_CONSTRAINTS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._known_annotated_metadata.UUID_CONSTRAINTS","name":"UUID_CONSTRAINTS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"ValidationError":{".class":"SymbolTableNode","cross_ref":"pydantic_core._pydantic_core.ValidationError","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._known_annotated_metadata.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._known_annotated_metadata.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._known_annotated_metadata.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._known_annotated_metadata.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._known_annotated_metadata.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._known_annotated_metadata.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_get_at_to_constraint_map":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated"],"fullname":"pydantic._internal._known_annotated_metadata._get_at_to_constraint_map","name":"_get_at_to_constraint_map","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_at_to_constraint_map","ret_type":{".class":"Instance","args":["builtins.type","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._known_annotated_metadata._get_at_to_constraint_map","name":"_get_at_to_constraint_map","setter_type":null,"type":{".class":"Instance","args":[{".class":"Instance","args":["builtins.type","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}],"extra_attrs":null,"type_ref":"functools._lru_cache_wrapper"}}}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"apply_known_metadata":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["annotation","schema"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._known_annotated_metadata.apply_known_metadata","name":"apply_known_metadata","original_first_arg":"annotation","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["annotation","schema"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"apply_known_metadata","ret_type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"as_jsonable_value":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._known_annotated_metadata.as_jsonable_value","name":"as_jsonable_value","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_jsonable_value","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"c":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_index_var","is_ready","is_inferred"],"fullname":"pydantic._internal._known_annotated_metadata.c","name":"c","setter_type":null,"type":"builtins.str"}},"check_metadata":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["metadata","allowed","source_type"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._known_annotated_metadata.check_metadata","name":"check_metadata","original_first_arg":"metadata","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["metadata","allowed","source_type"],"arg_types":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"check_metadata","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"collect_known_metadata":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["annotations"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._known_annotated_metadata.collect_known_metadata","name":"collect_known_metadata","original_first_arg":"annotations","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["annotations"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"collect_known_metadata","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"constraint_schema_pairings":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic._internal._known_annotated_metadata.constraint_schema_pairings","name":"constraint_schema_pairings","setter_type":null,"type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"builtins.list"}}},"constraints":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._known_annotated_metadata.constraints","name":"constraints","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"copy":{".class":"SymbolTableNode","cross_ref":"copy.copy","kind":"Gdef"},"cs":{".class":"SymbolTableNode","cross_ref":"pydantic_core.core_schema","kind":"Gdef"},"defaultdict":{".class":"SymbolTableNode","cross_ref":"collections.defaultdict","kind":"Gdef"},"expand_grouped_metadata":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["annotations"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._known_annotated_metadata.expand_grouped_metadata","name":"expand_grouped_metadata","original_first_arg":"annotations","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["annotations"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"expand_grouped_metadata","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Iterable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"import_cached_field_info":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._import_utils.import_cached_field_info","kind":"Gdef"},"lru_cache":{".class":"SymbolTableNode","cross_ref":"functools.lru_cache","kind":"Gdef"},"partial":{".class":"SymbolTableNode","cross_ref":"functools.partial","kind":"Gdef"},"schemas":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._known_annotated_metadata.schemas","name":"schemas","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}}},"to_jsonable_python":{".class":"SymbolTableNode","cross_ref":"pydantic_core._pydantic_core.to_jsonable_python","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_known_annotated_metadata.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_known_annotated_metadata.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_known_annotated_metadata.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..1a642112b25ccd11cb6f9f0bd5439faa79bd3e71 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_known_annotated_metadata.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[12,13,4,10,1,3,5,6,7,9,1,1,1,1],"dep_prios":[5,5,5,10,5,5,5,5,5,5,5,30,30,30],"dependencies":["pydantic._internal._fields","pydantic._internal._import_utils","collections.abc","pydantic_core.core_schema","__future__","collections","copy","functools","typing","pydantic_core","builtins","_frozen_importlib","_typeshed","abc"],"hash":"81639d1ca89bea881fca9ba644b33f9c45b4e2dd","id":"pydantic._internal._known_annotated_metadata","ignore_all":true,"interface_hash":"67c3f433a3e935c96bf92af45a76de2369bea52d","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_known_annotated_metadata.py","plugin_data":null,"size":16765,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_mock_val_ser.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_mock_val_ser.data.json new file mode 100644 index 0000000000000000000000000000000000000000..90e772a6ab0759743bd42ce6bf4465df211c8525 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_mock_val_ser.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic._internal._mock_val_ser","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseModel":{".class":"SymbolTableNode","cross_ref":"pydantic.main.BaseModel","kind":"Gdef"},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"CoreSchema":{".class":"SymbolTableNode","cross_ref":"pydantic_core.core_schema.CoreSchema","kind":"Gdef"},"Generic":{".class":"SymbolTableNode","cross_ref":"typing.Generic","kind":"Gdef"},"Iterator":{".class":"SymbolTableNode","cross_ref":"typing.Iterator","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"Mapping":{".class":"SymbolTableNode","cross_ref":"typing.Mapping","kind":"Gdef"},"MockCoreSchema":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Mapping"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._mock_val_ser.MockCoreSchema","name":"MockCoreSchema","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._mock_val_ser.MockCoreSchema","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic._internal._mock_val_ser","mro":["pydantic._internal._mock_val_ser.MockCoreSchema","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","__getitem__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._mock_val_ser.MockCoreSchema.__getitem__","name":"__getitem__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["pydantic._internal._mock_val_ser.MockCoreSchema","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of MockCoreSchema","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,3,5],"arg_names":["self","error_message","code","attempt_rebuild"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._mock_val_ser.MockCoreSchema.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,3,5],"arg_names":["self","error_message","code","attempt_rebuild"],"arg_types":["pydantic._internal._mock_val_ser.MockCoreSchema","builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.errors.PydanticErrorCodes"},{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of MockCoreSchema","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__iter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._mock_val_ser.MockCoreSchema.__iter__","name":"__iter__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["pydantic._internal._mock_val_ser.MockCoreSchema"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iter__ of MockCoreSchema","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__len__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._mock_val_ser.MockCoreSchema.__len__","name":"__len__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["pydantic._internal._mock_val_ser.MockCoreSchema"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__len__ of MockCoreSchema","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic._internal._mock_val_ser.MockCoreSchema.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_attempt_rebuild":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._mock_val_ser.MockCoreSchema._attempt_rebuild","name":"_attempt_rebuild","setter_type":null,"type":{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_built_memo":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic._internal._mock_val_ser.MockCoreSchema._built_memo","name":"_built_memo","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_code":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic._internal._mock_val_ser.MockCoreSchema._code","name":"_code","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.errors.PydanticErrorCodes"}}},"_error_message":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._mock_val_ser.MockCoreSchema._error_message","name":"_error_message","setter_type":null,"type":"builtins.str"}},"_get_built":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._mock_val_ser.MockCoreSchema._get_built","name":"_get_built","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._mock_val_ser.MockCoreSchema"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_built of MockCoreSchema","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"rebuild":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._mock_val_ser.MockCoreSchema.rebuild","name":"rebuild","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._mock_val_ser.MockCoreSchema"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rebuild of MockCoreSchema","ret_type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._mock_val_ser.MockCoreSchema.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._mock_val_ser.MockCoreSchema","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"MockValSer":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._mock_val_ser.MockValSer","name":"MockValSer","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._mock_val_ser.ValSer","id":1,"name":"ValSer","namespace":"pydantic._internal._mock_val_ser.MockValSer","upper_bound":{".class":"UnionType","items":["pydantic_core._pydantic_core.SchemaValidator","pydantic.plugin._schema_validator.PluggableSchemaValidator","pydantic_core._pydantic_core.SchemaSerializer"],"uses_pep604_syntax":false},"values":[],"variance":0}]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._mock_val_ser.MockValSer","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic._internal._mock_val_ser","mro":["pydantic._internal._mock_val_ser.MockValSer","builtins.object"],"names":{".class":"SymbolTable","__getattr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._mock_val_ser.MockValSer.__getattr__","name":"__getattr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._mock_val_ser.ValSer","id":1,"name":"ValSer","namespace":"pydantic._internal._mock_val_ser.MockValSer","upper_bound":{".class":"UnionType","items":["pydantic_core._pydantic_core.SchemaValidator","pydantic.plugin._schema_validator.PluggableSchemaValidator","pydantic_core._pydantic_core.SchemaSerializer"],"uses_pep604_syntax":false},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"pydantic._internal._mock_val_ser.MockValSer"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getattr__ of MockValSer","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,3,3,5],"arg_names":["self","error_message","code","val_or_ser","attempt_rebuild"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._mock_val_ser.MockValSer.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,3,3,5],"arg_names":["self","error_message","code","val_or_ser","attempt_rebuild"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._mock_val_ser.ValSer","id":1,"name":"ValSer","namespace":"pydantic._internal._mock_val_ser.MockValSer","upper_bound":{".class":"UnionType","items":["pydantic_core._pydantic_core.SchemaValidator","pydantic.plugin._schema_validator.PluggableSchemaValidator","pydantic_core._pydantic_core.SchemaSerializer"],"uses_pep604_syntax":false},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"pydantic._internal._mock_val_ser.MockValSer"},"builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.errors.PydanticErrorCodes"},{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"validator"},{".class":"LiteralType","fallback":"builtins.str","value":"serializer"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._mock_val_ser.ValSer","id":1,"name":"ValSer","namespace":"pydantic._internal._mock_val_ser.MockValSer","upper_bound":{".class":"UnionType","items":["pydantic_core._pydantic_core.SchemaValidator","pydantic.plugin._schema_validator.PluggableSchemaValidator","pydantic_core._pydantic_core.SchemaSerializer"],"uses_pep604_syntax":false},"values":[],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of MockValSer","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic._internal._mock_val_ser.MockValSer.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_attempt_rebuild":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._mock_val_ser.MockValSer._attempt_rebuild","name":"_attempt_rebuild","setter_type":null,"type":{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._mock_val_ser.ValSer","id":1,"name":"ValSer","namespace":"pydantic._internal._mock_val_ser.MockValSer","upper_bound":{".class":"UnionType","items":["pydantic_core._pydantic_core.SchemaValidator","pydantic.plugin._schema_validator.PluggableSchemaValidator","pydantic_core._pydantic_core.SchemaSerializer"],"uses_pep604_syntax":false},"values":[],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_code":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic._internal._mock_val_ser.MockValSer._code","name":"_code","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.errors.PydanticErrorCodes"}}},"_error_message":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._mock_val_ser.MockValSer._error_message","name":"_error_message","setter_type":null,"type":"builtins.str"}},"_val_or_ser":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._mock_val_ser.MockValSer._val_or_ser","name":"_val_or_ser","setter_type":null,"type":{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["schema","config"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreConfig"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.type","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":"SchemaValidator","ret_type":"pydantic_core._pydantic_core.SchemaValidator","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1],"arg_names":["schema","config"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreConfig"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.type","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":"SchemaSerializer","ret_type":"pydantic_core._pydantic_core.SchemaSerializer","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"uses_pep604_syntax":false}}},"rebuild":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._mock_val_ser.MockValSer.rebuild","name":"rebuild","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._mock_val_ser.ValSer","id":1,"name":"ValSer","namespace":"pydantic._internal._mock_val_ser.MockValSer","upper_bound":{".class":"UnionType","items":["pydantic_core._pydantic_core.SchemaValidator","pydantic.plugin._schema_validator.PluggableSchemaValidator","pydantic_core._pydantic_core.SchemaSerializer"],"uses_pep604_syntax":false},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"pydantic._internal._mock_val_ser.MockValSer"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rebuild of MockValSer","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._mock_val_ser.ValSer","id":1,"name":"ValSer","namespace":"pydantic._internal._mock_val_ser.MockValSer","upper_bound":{".class":"UnionType","items":["pydantic_core._pydantic_core.SchemaValidator","pydantic.plugin._schema_validator.PluggableSchemaValidator","pydantic_core._pydantic_core.SchemaSerializer"],"uses_pep604_syntax":false},"values":[],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._mock_val_ser.MockValSer.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._mock_val_ser.ValSer","id":1,"name":"ValSer","namespace":"pydantic._internal._mock_val_ser.MockValSer","upper_bound":{".class":"UnionType","items":["pydantic_core._pydantic_core.SchemaValidator","pydantic.plugin._schema_validator.PluggableSchemaValidator","pydantic_core._pydantic_core.SchemaSerializer"],"uses_pep604_syntax":false},"values":[],"variance":0}],"extra_attrs":null,"type_ref":"pydantic._internal._mock_val_ser.MockValSer"},"values":[],"variance":0},"slots":["_attempt_rebuild","_code","_error_message","_val_or_ser"],"tuple_type":null,"type_vars":["ValSer"],"typeddict_type":null}},"PluggableSchemaValidator":{".class":"SymbolTableNode","cross_ref":"pydantic.plugin._schema_validator.PluggableSchemaValidator","kind":"Gdef"},"PydanticDataclass":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._dataclasses.PydanticDataclass","kind":"Gdef"},"PydanticErrorCodes":{".class":"SymbolTableNode","cross_ref":"pydantic.errors.PydanticErrorCodes","kind":"Gdef"},"PydanticUserError":{".class":"SymbolTableNode","cross_ref":"pydantic.errors.PydanticUserError","kind":"Gdef"},"SchemaSerializer":{".class":"SymbolTableNode","cross_ref":"pydantic_core._pydantic_core.SchemaSerializer","kind":"Gdef"},"SchemaValidator":{".class":"SymbolTableNode","cross_ref":"pydantic_core._pydantic_core.SchemaValidator","kind":"Gdef"},"T":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._mock_val_ser.T","name":"T","upper_bound":"builtins.object","values":[],"variance":0}},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"TypeAdapter":{".class":"SymbolTableNode","cross_ref":"pydantic.type_adapter.TypeAdapter","kind":"Gdef"},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"ValSer":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._mock_val_ser.ValSer","name":"ValSer","upper_bound":{".class":"UnionType","items":["pydantic_core._pydantic_core.SchemaValidator","pydantic.plugin._schema_validator.PluggableSchemaValidator","pydantic_core._pydantic_core.SchemaSerializer"],"uses_pep604_syntax":false},"values":[],"variance":0}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._mock_val_ser.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._mock_val_ser.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._mock_val_ser.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._mock_val_ser.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._mock_val_ser.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._mock_val_ser.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"set_dataclass_mocks":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["cls","undefined_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._mock_val_ser.set_dataclass_mocks","name":"set_dataclass_mocks","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["cls","undefined_name"],"arg_types":[{".class":"TypeType","item":"pydantic._internal._dataclasses.PydanticDataclass"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"set_dataclass_mocks","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"set_model_mocks":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["cls","undefined_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._mock_val_ser.set_model_mocks","name":"set_model_mocks","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["cls","undefined_name"],"arg_types":[{".class":"TypeType","item":"pydantic.main.BaseModel"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"set_model_mocks","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"set_type_adapter_mocks":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["adapter"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._mock_val_ser.set_type_adapter_mocks","name":"set_type_adapter_mocks","original_first_arg":"adapter","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["adapter"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"pydantic.type_adapter.TypeAdapter"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"set_type_adapter_mocks","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_mock_val_ser.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_mock_val_ser.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_mock_val_ser.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..dcb9fe0ecd319e3e187f3a38741e6f6e4ea0224f --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_mock_val_ser.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[9,3,8,12,13,14,1,4,6,1,1,1,1,1,1,1,1,1],"dep_prios":[5,5,5,25,25,25,5,5,5,5,30,30,30,30,30,30,30,30],"dependencies":["pydantic.plugin._schema_validator","collections.abc","pydantic.errors","pydantic.dataclasses","pydantic.main","pydantic.type_adapter","__future__","typing","pydantic_core","builtins","_frozen_importlib","_typeshed","abc","pydantic._internal._dataclasses","pydantic._internal._model_construction","pydantic.plugin","pydantic_core._pydantic_core","pydantic_core.core_schema"],"hash":"e68ec0a0e8bb9feae8494f568f60ebffbe93004a","id":"pydantic._internal._mock_val_ser","ignore_all":true,"interface_hash":"a63849c7f863ad79a827520b9326b57522815eea","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_mock_val_ser.py","plugin_data":null,"size":8885,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_model_construction.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_model_construction.data.json new file mode 100644 index 0000000000000000000000000000000000000000..192ecc403687578cbecc633b8e1ff133450ec667 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_model_construction.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic._internal._model_construction","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","ABCMeta":{".class":"SymbolTableNode","cross_ref":"abc.ABCMeta","kind":"Gdef"},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseModel":{".class":"SymbolTableNode","cross_ref":"pydantic.main.BaseModel","kind":"Gdef"},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"ConfigWrapper":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._config.ConfigWrapper","kind":"Gdef"},"DecoratorInfos":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._decorators.DecoratorInfos","kind":"Gdef"},"FieldInfo":{".class":"SymbolTableNode","cross_ref":"pydantic.fields.FieldInfo","kind":"Gdef"},"FunctionType":{".class":"SymbolTableNode","cross_ref":"types.FunctionType","kind":"Gdef"},"GenerateSchema":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._generate_schema.GenerateSchema","kind":"Gdef"},"Generic":{".class":"SymbolTableNode","cross_ref":"typing.Generic","kind":"Gdef"},"GenericBeforeBaseModelWarning":{".class":"SymbolTableNode","cross_ref":"pydantic.warnings.GenericBeforeBaseModelWarning","kind":"Gdef"},"InvalidSchemaError":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._generate_schema.InvalidSchemaError","kind":"Gdef"},"LazyClassAttribute":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._utils.LazyClassAttribute","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"ModelMetaclass":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["abc.ABCMeta"],"dataclass_transform_spec":{"eq_default":true,"field_specifiers":["pydantic.fields.Field","pydantic.fields.PrivateAttr","pydantic._internal._model_construction.NoInitField"],"frozen_default":false,"kw_only_default":true,"order_default":false},"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._model_construction.ModelMetaclass","name":"ModelMetaclass","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._model_construction.ModelMetaclass","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic._internal._model_construction","mro":["pydantic._internal._model_construction.ModelMetaclass","abc.ABCMeta","builtins.type","builtins.object"],"names":{".class":"SymbolTable","__dir__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._model_construction.ModelMetaclass.__dir__","name":"__dir__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._model_construction.ModelMetaclass"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__dir__ of ModelMetaclass","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":"function pydantic._internal._model_construction.ModelMetaclass.__fields__ is deprecated: The `__fields__` attribute is deprecated, use the `model_fields` class property instead.","flags":["is_property","is_decorated","is_trivial_self"],"fullname":"pydantic._internal._model_construction.ModelMetaclass.__fields__","name":"__fields__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._model_construction.ModelMetaclass"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__fields__ of ModelMetaclass","ret_type":{".class":"Instance","args":["builtins.str","pydantic.fields.FieldInfo"],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"pydantic._internal._model_construction.ModelMetaclass.__fields__","name":"__fields__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._model_construction.ModelMetaclass"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__fields__ of ModelMetaclass","ret_type":{".class":"Instance","args":["builtins.str","pydantic.fields.FieldInfo"],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__instancecheck__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._model_construction.ModelMetaclass.__instancecheck__","name":"__instancecheck__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["builtins.type",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__new__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1,1,1,4],"arg_names":["mcs","cls_name","bases","namespace","__pydantic_generic_metadata__","__pydantic_reset_parent_namespace__","_create_model_module","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_trivial_self"],"fullname":"pydantic._internal._model_construction.ModelMetaclass.__new__","name":"__new__","original_first_arg":"mcs","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1,1,1,4],"arg_names":["mcs","cls_name","bases","namespace","__pydantic_generic_metadata__","__pydantic_reset_parent_namespace__","_create_model_module","kwargs"],"arg_types":[{".class":"TypeType","item":"pydantic._internal._model_construction.ModelMetaclass"},"builtins.str",{".class":"Instance","args":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._generics.PydanticGenericMetadata"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of ModelMetaclass","ret_type":"builtins.type","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__prepare__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":["cls","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic._internal._model_construction.ModelMetaclass.__prepare__","name":"__prepare__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":["cls","args","kwargs"],"arg_types":[{".class":"TypeType","item":"pydantic._internal._model_construction.ModelMetaclass"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__prepare__ of ModelMetaclass","ret_type":{".class":"Instance","args":["builtins.str","builtins.object"],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic._internal._model_construction.ModelMetaclass.__prepare__","name":"__prepare__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":["cls","args","kwargs"],"arg_types":[{".class":"TypeType","item":"pydantic._internal._model_construction.ModelMetaclass"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__prepare__ of ModelMetaclass","ret_type":{".class":"Instance","args":["builtins.str","builtins.object"],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__pydantic_fields_complete__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"pydantic._internal._model_construction.ModelMetaclass.__pydantic_fields_complete__","name":"__pydantic_fields_complete__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._model_construction.ModelMetaclass"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__pydantic_fields_complete__ of ModelMetaclass","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"pydantic._internal._model_construction.ModelMetaclass.__pydantic_fields_complete__","name":"__pydantic_fields_complete__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._model_construction.ModelMetaclass"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__pydantic_fields_complete__ of ModelMetaclass","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__subclasscheck__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._model_construction.ModelMetaclass.__subclasscheck__","name":"__subclasscheck__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["builtins.type","builtins.type"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_collect_bases_data":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["bases"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"pydantic._internal._model_construction.ModelMetaclass._collect_bases_data","name":"_collect_bases_data","original_first_arg":"bases","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["bases"],"arg_types":[{".class":"Instance","args":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_collect_bases_data of ModelMetaclass","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"Instance","args":["builtins.str","pydantic.fields.ModelPrivateAttr"],"extra_attrs":null,"type_ref":"builtins.dict"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_staticmethod","is_ready","is_inferred"],"fullname":"pydantic._internal._model_construction.ModelMetaclass._collect_bases_data","name":"_collect_bases_data","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["bases"],"arg_types":[{".class":"Instance","args":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_collect_bases_data of ModelMetaclass","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"Instance","args":["builtins.str","pydantic.fields.ModelPrivateAttr"],"extra_attrs":null,"type_ref":"builtins.dict"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"register":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","subclass"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._model_construction.ModelMetaclass.register","name":"register","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","subclass"],"arg_types":["pydantic._internal._model_construction.ModelMetaclass",{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._model_construction._T","id":-1,"name":"_T","namespace":"pydantic._internal._model_construction.ModelMetaclass.register","upper_bound":"builtins.object","values":[],"variance":0}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"register of ModelMetaclass","ret_type":{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._model_construction._T","id":-1,"name":"_T","namespace":"pydantic._internal._model_construction.ModelMetaclass.register","upper_bound":"builtins.object","values":[],"variance":0}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._model_construction._T","id":-1,"name":"_T","namespace":"pydantic._internal._model_construction.ModelMetaclass.register","upper_bound":"builtins.object","values":[],"variance":0}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._model_construction.ModelMetaclass.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._model_construction.ModelMetaclass","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ModelPrivateAttr":{".class":"SymbolTableNode","cross_ref":"pydantic.fields.ModelPrivateAttr","kind":"Gdef"},"NoInitField":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5],"arg_names":["init"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._model_construction.NoInitField","name":"NoInitField","original_first_arg":"init","type":{".class":"CallableType","arg_kinds":[5],"arg_names":["init"],"arg_types":[{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"NoInitField","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"NoReturn":{".class":"SymbolTableNode","cross_ref":"typing.NoReturn","kind":"Gdef"},"NsResolver":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._namespace_utils.NsResolver","kind":"Gdef"},"PydanticDeprecatedSince20":{".class":"SymbolTableNode","cross_ref":"pydantic.warnings.PydanticDeprecatedSince20","kind":"Gdef"},"PydanticDescriptorProxy":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._decorators.PydanticDescriptorProxy","kind":"Gdef"},"PydanticGenericMetadata":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._generics.PydanticGenericMetadata","kind":"Gdef"},"PydanticModelField":{".class":"SymbolTableNode","cross_ref":"pydantic.fields.Field","kind":"Gdef"},"PydanticModelPrivateAttr":{".class":"SymbolTableNode","cross_ref":"pydantic.fields.PrivateAttr","kind":"Gdef"},"PydanticUndefined":{".class":"SymbolTableNode","cross_ref":"pydantic_core._pydantic_core.PydanticUndefined","kind":"Gdef"},"PydanticUndefinedAnnotation":{".class":"SymbolTableNode","cross_ref":"pydantic.errors.PydanticUndefinedAnnotation","kind":"Gdef"},"PydanticUserError":{".class":"SymbolTableNode","cross_ref":"pydantic.errors.PydanticUserError","kind":"Gdef"},"SafeGetItemProxy":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._utils.SafeGetItemProxy","kind":"Gdef"},"SchemaSerializer":{".class":"SymbolTableNode","cross_ref":"pydantic_core._pydantic_core.SchemaSerializer","kind":"Gdef"},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"TypeAliasType":{".class":"SymbolTableNode","cross_ref":"typing_extensions.TypeAliasType","kind":"Gdef"},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef"},"_DeprecatedFieldDescriptor":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._model_construction._DeprecatedFieldDescriptor","name":"_DeprecatedFieldDescriptor","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._model_construction._DeprecatedFieldDescriptor","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic._internal._model_construction","mro":["pydantic._internal._model_construction._DeprecatedFieldDescriptor","builtins.object"],"names":{".class":"SymbolTable","__get__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","obj","obj_type"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._model_construction._DeprecatedFieldDescriptor.__get__","name":"__get__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","obj","obj_type"],"arg_types":["pydantic._internal._model_construction._DeprecatedFieldDescriptor",{".class":"UnionType","items":["pydantic.main.BaseModel",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeType","item":"pydantic.main.BaseModel"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get__ of _DeprecatedFieldDescriptor","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","msg","wrapped_property"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._model_construction._DeprecatedFieldDescriptor.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","msg","wrapped_property"],"arg_types":["pydantic._internal._model_construction._DeprecatedFieldDescriptor","builtins.str",{".class":"UnionType","items":["builtins.property",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of _DeprecatedFieldDescriptor","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__set__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","obj","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._model_construction._DeprecatedFieldDescriptor.__set__","name":"__set__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","obj","value"],"arg_types":["pydantic._internal._model_construction._DeprecatedFieldDescriptor",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__set__ of _DeprecatedFieldDescriptor","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__set_name__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","cls","name"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._model_construction._DeprecatedFieldDescriptor.__set_name__","name":"__set_name__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","cls","name"],"arg_types":["pydantic._internal._model_construction._DeprecatedFieldDescriptor",{".class":"TypeType","item":"pydantic.main.BaseModel"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__set_name__ of _DeprecatedFieldDescriptor","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"field_name":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._model_construction._DeprecatedFieldDescriptor.field_name","name":"field_name","setter_type":null,"type":"builtins.str"}},"msg":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._model_construction._DeprecatedFieldDescriptor.msg","name":"msg","setter_type":null,"type":"builtins.str"}},"wrapped_property":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._model_construction._DeprecatedFieldDescriptor.wrapped_property","name":"wrapped_property","setter_type":null,"type":{".class":"UnionType","items":["builtins.property",{".class":"NoneType"}],"uses_pep604_syntax":true}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._model_construction._DeprecatedFieldDescriptor.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._model_construction._DeprecatedFieldDescriptor","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_ModelNamespaceDict":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.dict"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._model_construction._ModelNamespaceDict","name":"_ModelNamespaceDict","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._model_construction._ModelNamespaceDict","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic._internal._model_construction","mro":["pydantic._internal._model_construction._ModelNamespaceDict","builtins.dict","typing.MutableMapping","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","__setitem__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":[null,null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._model_construction._ModelNamespaceDict.__setitem__","name":"__setitem__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,null,null],"arg_types":["pydantic._internal._model_construction._ModelNamespaceDict","builtins.str","builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__setitem__ of _ModelNamespaceDict","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._model_construction._ModelNamespaceDict.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._model_construction._ModelNamespaceDict","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_PydanticWeakRef":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._model_construction._PydanticWeakRef","name":"_PydanticWeakRef","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._model_construction._PydanticWeakRef","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic._internal._model_construction","mro":["pydantic._internal._model_construction._PydanticWeakRef","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._model_construction._PydanticWeakRef.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._model_construction._PydanticWeakRef"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _PydanticWeakRef","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._model_construction._PydanticWeakRef.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","obj"],"arg_types":["pydantic._internal._model_construction._PydanticWeakRef",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of _PydanticWeakRef","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__reduce__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._model_construction._PydanticWeakRef.__reduce__","name":"__reduce__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._model_construction._PydanticWeakRef"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__reduce__ of _PydanticWeakRef","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"weakref.ReferenceType"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_wr":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._model_construction._PydanticWeakRef._wr","name":"_wr","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_of_any":7}],"extra_attrs":null,"type_ref":"weakref.ReferenceType"},{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._model_construction._PydanticWeakRef.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._model_construction._PydanticWeakRef","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_T":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._model_construction._T","name":"_T","upper_bound":"builtins.object","values":[],"variance":0}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._model_construction.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._model_construction.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._model_construction.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._model_construction.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._model_construction.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._model_construction.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"_make_forward_ref":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._typing_extra._make_forward_ref","kind":"Gdef"},"build_lenient_weakvaluedict":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["d"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._model_construction.build_lenient_weakvaluedict","name":"build_lenient_weakvaluedict","original_first_arg":"d","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["d"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"build_lenient_weakvaluedict","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"cache":{".class":"SymbolTableNode","cross_ref":"functools.cache","kind":"Gdef"},"cast":{".class":"SymbolTableNode","cross_ref":"typing.cast","kind":"Gdef"},"collect_model_fields":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._fields.collect_model_fields","kind":"Gdef"},"complete_model_class":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5,5,5],"arg_names":["cls","config_wrapper","ns_resolver","raise_errors","call_on_complete_hook","create_model_module"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._model_construction.complete_model_class","name":"complete_model_class","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0,0,5,5,5],"arg_names":["cls","config_wrapper","ns_resolver","raise_errors","call_on_complete_hook","create_model_module"],"arg_types":[{".class":"TypeType","item":"pydantic.main.BaseModel"},"pydantic._internal._config.ConfigWrapper","pydantic._internal._namespace_utils.NsResolver","builtins.bool","builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"complete_model_class","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"create_schema_validator":{".class":"SymbolTableNode","cross_ref":"pydantic.plugin._schema_validator.create_schema_validator","kind":"Gdef"},"dataclass_transform":{".class":"SymbolTableNode","cross_ref":"typing_extensions.dataclass_transform","kind":"Gdef"},"default_ignored_types":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated"],"fullname":"pydantic._internal._model_construction.default_ignored_types","name":"default_ignored_types","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"default_ignored_types","ret_type":{".class":"Instance","args":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._model_construction.default_ignored_types","name":"default_ignored_types","setter_type":null,"type":{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"extra_attrs":null,"type_ref":"functools._lru_cache_wrapper"}}}},"deprecated":{".class":"SymbolTableNode","cross_ref":"typing_extensions.deprecated","kind":"Gdef"},"eval_type_backport":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._typing_extra.eval_type_backport","kind":"Gdef"},"generate_pydantic_signature":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._signature.generate_pydantic_signature","kind":"Gdef"},"get_args":{".class":"SymbolTableNode","cross_ref":"typing_extensions.get_args","kind":"Gdef"},"get_attribute_from_bases":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._decorators.get_attribute_from_bases","kind":"Gdef"},"get_model_post_init":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["namespace","bases"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._model_construction.get_model_post_init","name":"get_model_post_init","original_first_arg":"namespace","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["namespace","bases"],"arg_types":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_model_post_init","ret_type":{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_model_typevars_map":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._generics.get_model_typevars_map","kind":"Gdef"},"get_origin":{".class":"SymbolTableNode","cross_ref":"typing_extensions.get_origin","kind":"Gdef"},"import_cached_base_model":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._import_utils.import_cached_base_model","kind":"Gdef"},"import_cached_field_info":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._import_utils.import_cached_field_info","kind":"Gdef"},"init_private_attributes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._model_construction.init_private_attributes","name":"init_private_attributes","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["pydantic.main.BaseModel",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"init_private_attributes","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"inspect_namespace":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0],"arg_names":["namespace","raw_annotations","ignored_types","base_class_vars","base_class_fields"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._model_construction.inspect_namespace","name":"inspect_namespace","original_first_arg":"namespace","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":["namespace","raw_annotations","ignored_types","base_class_vars","base_class_fields"],"arg_types":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"inspect_namespace","ret_type":{".class":"Instance","args":["builtins.str","pydantic.fields.ModelPrivateAttr"],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_classvar_annotation":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._typing_extra.is_classvar_annotation","kind":"Gdef"},"is_valid_field_name":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._fields.is_valid_field_name","kind":"Gdef"},"is_valid_privateattr_name":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._fields.is_valid_privateattr_name","kind":"Gdef"},"make_hash_func":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._model_construction.make_hash_func","name":"make_hash_func","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.main.BaseModel"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"make_hash_func","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"object_setattr":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._model_construction.object_setattr","name":"object_setattr","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,null,null],"arg_types":["builtins.object","builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"operator":{".class":"SymbolTableNode","cross_ref":"operator","kind":"Gdef"},"parent_frame_namespace":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._typing_extra.parent_frame_namespace","kind":"Gdef"},"partial":{".class":"SymbolTableNode","cross_ref":"functools.partial","kind":"Gdef"},"rebuild_model_fields":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._fields.rebuild_model_fields","kind":"Gdef"},"set_default_hash_func":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","bases"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._model_construction.set_default_hash_func","name":"set_default_hash_func","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","bases"],"arg_types":[{".class":"TypeType","item":"pydantic.main.BaseModel"},{".class":"Instance","args":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"set_default_hash_func","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"set_deprecated_descriptors":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._model_construction.set_deprecated_descriptors","name":"set_deprecated_descriptors","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.main.BaseModel"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"set_deprecated_descriptors","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"set_model_fields":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["cls","config_wrapper","ns_resolver"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._model_construction.set_model_fields","name":"set_model_fields","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["cls","config_wrapper","ns_resolver"],"arg_types":[{".class":"TypeType","item":"pydantic.main.BaseModel"},"pydantic._internal._config.ConfigWrapper",{".class":"UnionType","items":["pydantic._internal._namespace_utils.NsResolver",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"set_model_fields","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"set_model_mocks":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._mock_val_ser.set_model_mocks","kind":"Gdef"},"sys":{".class":"SymbolTableNode","cross_ref":"sys","kind":"Gdef"},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef"},"typing_objects":{".class":"SymbolTableNode","cross_ref":"typing_inspection.typing_objects","kind":"Gdef"},"unpack_lenient_weakvaluedict":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["d"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._model_construction.unpack_lenient_weakvaluedict","name":"unpack_lenient_weakvaluedict","original_first_arg":"d","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["d"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unpack_lenient_weakvaluedict","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"unwrap_wrapped_function":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._decorators.unwrap_wrapped_function","kind":"Gdef"},"warnings":{".class":"SymbolTableNode","cross_ref":"warnings","kind":"Gdef"},"weakref":{".class":"SymbolTableNode","cross_ref":"weakref","kind":"Gdef"},"wraps":{".class":"SymbolTableNode","cross_ref":"functools.wraps","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_model_construction.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_model_construction.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_model_construction.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..377c7593b10133b26630b757beb5234a7a7cf82f --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_model_construction.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[20,22,23,24,25,26,27,28,29,30,31,37,17,19,21,40,43,185,3,5,6,7,8,9,10,11,12,15,16,17,1,1,1,1,1,1,1,1],"dep_prios":[5,5,5,5,5,5,5,5,5,5,5,5,10,5,5,25,25,20,5,10,10,5,10,10,5,5,5,5,5,20,5,30,30,30,30,30,30,30],"dependencies":["pydantic.plugin._schema_validator","pydantic._internal._config","pydantic._internal._decorators","pydantic._internal._fields","pydantic._internal._generate_schema","pydantic._internal._generics","pydantic._internal._import_utils","pydantic._internal._mock_val_ser","pydantic._internal._namespace_utils","pydantic._internal._signature","pydantic._internal._typing_extra","pydantic._internal._utils","typing_inspection.typing_objects","pydantic.errors","pydantic.warnings","pydantic.fields","pydantic.main","pydantic.root_model","__future__","operator","sys","typing","warnings","weakref","abc","functools","types","pydantic_core","typing_extensions","typing_inspection","builtins","_frozen_importlib","_typeshed","annotated_types","pydantic._internal._repr","pydantic.aliases","pydantic.types","re"],"hash":"2abcee14b6389c5ad33f9b9ff0c81d4b0e878b09","id":"pydantic._internal._model_construction","ignore_all":true,"interface_hash":"bc3dfdfcfa083a8ba8cb6863770b9993f5ab20d2","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_model_construction.py","plugin_data":null,"size":37783,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_namespace_utils.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_namespace_utils.data.json new file mode 100644 index 0000000000000000000000000000000000000000..4c4a84f3b90eb78438eeaf238b721e9b3685e458 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_namespace_utils.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic._internal._namespace_utils","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"Generator":{".class":"SymbolTableNode","cross_ref":"typing.Generator","kind":"Gdef"},"GlobalsNamespace":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic._internal._namespace_utils.GlobalsNamespace","line":11,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"Iterator":{".class":"SymbolTableNode","cross_ref":"typing.Iterator","kind":"Gdef"},"LazyLocalNamespace":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Mapping"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._namespace_utils.LazyLocalNamespace","name":"LazyLocalNamespace","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._namespace_utils.LazyLocalNamespace","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic._internal._namespace_utils","mro":["pydantic._internal._namespace_utils.LazyLocalNamespace","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","__contains__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._namespace_utils.LazyLocalNamespace.__contains__","name":"__contains__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["pydantic._internal._namespace_utils.LazyLocalNamespace","builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__contains__ of LazyLocalNamespace","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__getitem__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._namespace_utils.LazyLocalNamespace.__getitem__","name":"__getitem__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["pydantic._internal._namespace_utils.LazyLocalNamespace","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of LazyLocalNamespace","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2],"arg_names":["self","namespaces"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._namespace_utils.LazyLocalNamespace.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2],"arg_names":["self","namespaces"],"arg_types":["pydantic._internal._namespace_utils.LazyLocalNamespace",{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of LazyLocalNamespace","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__iter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._namespace_utils.LazyLocalNamespace.__iter__","name":"__iter__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["pydantic._internal._namespace_utils.LazyLocalNamespace"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iter__ of LazyLocalNamespace","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__len__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._namespace_utils.LazyLocalNamespace.__len__","name":"__len__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["pydantic._internal._namespace_utils.LazyLocalNamespace"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__len__ of LazyLocalNamespace","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_namespaces":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._namespace_utils.LazyLocalNamespace._namespaces","name":"_namespaces","setter_type":null,"type":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"}],"extra_attrs":null,"type_ref":"builtins.tuple"}}},"data":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"pydantic._internal._namespace_utils.LazyLocalNamespace.data","name":"data","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._namespace_utils.LazyLocalNamespace"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"data of LazyLocalNamespace","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_settable_property","is_ready","is_inferred"],"fullname":"pydantic._internal._namespace_utils.LazyLocalNamespace.data","name":"data","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._namespace_utils.LazyLocalNamespace"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"data of LazyLocalNamespace","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._namespace_utils.LazyLocalNamespace.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._namespace_utils.LazyLocalNamespace","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Mapping":{".class":"SymbolTableNode","cross_ref":"typing.Mapping","kind":"Gdef"},"MappingNamespace":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic._internal._namespace_utils.MappingNamespace","line":18,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Mapping"}}},"NamedTuple":{".class":"SymbolTableNode","cross_ref":"typing.NamedTuple","kind":"Gdef"},"NamespacesTuple":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Mapping"}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._namespace_utils.NamespacesTuple","name":"NamespacesTuple","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_named_tuple"],"fullname":"pydantic._internal._namespace_utils.NamespacesTuple","has_param_spec_type":false,"metaclass_type":null,"metadata":{"namedtuple":{"fields":["globals","locals"]}},"module_name":"pydantic._internal._namespace_utils","mro":["pydantic._internal._namespace_utils.NamespacesTuple","builtins.tuple","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","_NT":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._namespace_utils.NamespacesTuple._NT","name":"_NT","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.GlobalsNamespace"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"}],"partial_fallback":{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Mapping"}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},"__annotations__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._namespace_utils.NamespacesTuple.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._namespace_utils.NamespacesTuple.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__new__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["_cls","globals","locals"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static"],"fullname":"pydantic._internal._namespace_utils.NamespacesTuple.__new__","name":"__new__","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["_cls","globals","locals"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._namespace_utils.NamespacesTuple._NT","id":-1,"name":"_NT","namespace":"pydantic._internal._namespace_utils.NamespacesTuple.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.GlobalsNamespace"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"}],"partial_fallback":{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Mapping"}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.GlobalsNamespace"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of NamespacesTuple","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._namespace_utils.NamespacesTuple._NT","id":-1,"name":"_NT","namespace":"pydantic._internal._namespace_utils.NamespacesTuple.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.GlobalsNamespace"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"}],"partial_fallback":{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Mapping"}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._namespace_utils.NamespacesTuple._NT","id":-1,"name":"_NT","namespace":"pydantic._internal._namespace_utils.NamespacesTuple.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.GlobalsNamespace"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"}],"partial_fallback":{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Mapping"}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_asdict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["_self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._namespace_utils.NamespacesTuple._asdict","name":"_asdict","original_first_arg":"_self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["_self"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._namespace_utils.NamespacesTuple._NT","id":-1,"name":"_NT","namespace":"pydantic._internal._namespace_utils.NamespacesTuple._asdict","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.GlobalsNamespace"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"}],"partial_fallback":{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Mapping"}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_asdict of NamespacesTuple","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._namespace_utils.NamespacesTuple._NT","id":-1,"name":"_NT","namespace":"pydantic._internal._namespace_utils.NamespacesTuple._asdict","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.GlobalsNamespace"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"}],"partial_fallback":{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Mapping"}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_field_defaults":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._namespace_utils.NamespacesTuple._field_defaults","name":"_field_defaults","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_field_types":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._namespace_utils.NamespacesTuple._field_types","name":"_field_types","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_fields":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._namespace_utils.NamespacesTuple._fields","name":"_fields","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_make":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["_cls","iterable"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated"],"fullname":"pydantic._internal._namespace_utils.NamespacesTuple._make","name":"_make","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["_cls","iterable"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._namespace_utils.NamespacesTuple._NT","id":-1,"name":"_NT","namespace":"pydantic._internal._namespace_utils.NamespacesTuple._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.GlobalsNamespace"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"}],"partial_fallback":{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Mapping"}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_make of NamespacesTuple","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._namespace_utils.NamespacesTuple._NT","id":-1,"name":"_NT","namespace":"pydantic._internal._namespace_utils.NamespacesTuple._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.GlobalsNamespace"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"}],"partial_fallback":{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Mapping"}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._namespace_utils.NamespacesTuple._NT","id":-1,"name":"_NT","namespace":"pydantic._internal._namespace_utils.NamespacesTuple._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.GlobalsNamespace"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"}],"partial_fallback":{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Mapping"}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_classmethod","is_ready"],"fullname":"pydantic._internal._namespace_utils.NamespacesTuple._make","name":"_make","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["_cls","iterable"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._namespace_utils.NamespacesTuple._NT","id":-1,"name":"_NT","namespace":"pydantic._internal._namespace_utils.NamespacesTuple._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.GlobalsNamespace"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"}],"partial_fallback":{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Mapping"}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_make of NamespacesTuple","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._namespace_utils.NamespacesTuple._NT","id":-1,"name":"_NT","namespace":"pydantic._internal._namespace_utils.NamespacesTuple._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.GlobalsNamespace"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"}],"partial_fallback":{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Mapping"}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._namespace_utils.NamespacesTuple._NT","id":-1,"name":"_NT","namespace":"pydantic._internal._namespace_utils.NamespacesTuple._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.GlobalsNamespace"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"}],"partial_fallback":{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Mapping"}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}}},"plugin_generated":true},"_replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5],"arg_names":["_self","globals","locals"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._namespace_utils.NamespacesTuple._replace","name":"_replace","original_first_arg":"_self","type":{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":["_self","globals","locals"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._namespace_utils.NamespacesTuple._NT","id":-1,"name":"_NT","namespace":"pydantic._internal._namespace_utils.NamespacesTuple._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.GlobalsNamespace"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"}],"partial_fallback":{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Mapping"}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.GlobalsNamespace"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_replace of NamespacesTuple","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._namespace_utils.NamespacesTuple._NT","id":-1,"name":"_NT","namespace":"pydantic._internal._namespace_utils.NamespacesTuple._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.GlobalsNamespace"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"}],"partial_fallback":{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Mapping"}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._namespace_utils.NamespacesTuple._NT","id":-1,"name":"_NT","namespace":"pydantic._internal._namespace_utils.NamespacesTuple._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.GlobalsNamespace"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"}],"partial_fallback":{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Mapping"}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_source":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._namespace_utils.NamespacesTuple._source","name":"_source","setter_type":null,"type":"builtins.str"}},"globals":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"pydantic._internal._namespace_utils.NamespacesTuple.globals","name":"globals","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.GlobalsNamespace"}}},"globals-redefinition":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._namespace_utils.NamespacesTuple.globals","kind":"Mdef"},"locals":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"pydantic._internal._namespace_utils.NamespacesTuple.locals","name":"locals","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"}}},"locals-redefinition":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._namespace_utils.NamespacesTuple.locals","kind":"Mdef"}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._namespace_utils.NamespacesTuple.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.GlobalsNamespace"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"}],"partial_fallback":"pydantic._internal._namespace_utils.NamespacesTuple"},"values":[],"variance":0},"slots":null,"tuple_type":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.GlobalsNamespace"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"}],"partial_fallback":{".class":"Instance","args":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Mapping"}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_vars":[],"typeddict_type":null}},"NsResolver":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._namespace_utils.NsResolver","name":"NsResolver","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._namespace_utils.NsResolver","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic._internal._namespace_utils","mro":["pydantic._internal._namespace_utils.NsResolver","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["self","namespaces_tuple","parent_namespace"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._namespace_utils.NsResolver.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","namespaces_tuple","parent_namespace"],"arg_types":["pydantic._internal._namespace_utils.NsResolver",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.NamespacesTuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of NsResolver","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_base_ns_tuple":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._namespace_utils.NsResolver._base_ns_tuple","name":"_base_ns_tuple","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.GlobalsNamespace"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"}],"partial_fallback":"pydantic._internal._namespace_utils.NamespacesTuple"}}},"_parent_ns":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._namespace_utils.NsResolver._parent_ns","name":"_parent_ns","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"},{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_types_stack":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic._internal._namespace_utils.NsResolver._types_stack","name":"_types_stack","setter_type":null,"type":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},"typing_extensions.TypeAliasType"],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.list"}}},"push":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated","is_trivial_self"],"fullname":"pydantic._internal._namespace_utils.NsResolver.push","name":"push","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["pydantic._internal._namespace_utils.NsResolver",{".class":"UnionType","items":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},"typing_extensions.TypeAliasType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"push of NsResolver","ret_type":{".class":"Instance","args":[{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Generator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred"],"fullname":"pydantic._internal._namespace_utils.NsResolver.push","name":"push","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["pydantic._internal._namespace_utils.NsResolver",{".class":"UnionType","items":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},"typing_extensions.TypeAliasType"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"push of NsResolver","ret_type":{".class":"Instance","args":[{".class":"NoneType"},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"types_namespace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"pydantic._internal._namespace_utils.NsResolver.types_namespace","name":"types_namespace","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._namespace_utils.NsResolver"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"types_namespace of NsResolver","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.NamespacesTuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_settable_property","is_ready","is_inferred"],"fullname":"pydantic._internal._namespace_utils.NsResolver.types_namespace","name":"types_namespace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._namespace_utils.NsResolver"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"types_namespace of NsResolver","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.NamespacesTuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._namespace_utils.NsResolver.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._namespace_utils.NsResolver","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ParamSpec":{".class":"SymbolTableNode","cross_ref":"typing_extensions.ParamSpec","kind":"Gdef"},"TypeAlias":{".class":"SymbolTableNode","cross_ref":"typing_extensions.TypeAlias","kind":"Gdef"},"TypeAliasType":{".class":"SymbolTableNode","cross_ref":"typing_extensions.TypeAliasType","kind":"Gdef"},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef"},"TypeVarTuple":{".class":"SymbolTableNode","cross_ref":"typing_extensions.TypeVarTuple","kind":"Gdef"},"_TypeVarLike":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic._internal._namespace_utils._TypeVarLike","line":27,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["typing.TypeVar","typing_extensions.ParamSpec","typing_extensions.TypeVarTuple"],"uses_pep604_syntax":true}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._namespace_utils.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._namespace_utils.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._namespace_utils.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._namespace_utils.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._namespace_utils.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._namespace_utils.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"cached_property":{".class":"SymbolTableNode","cross_ref":"functools.cached_property","kind":"Gdef"},"contextmanager":{".class":"SymbolTableNode","cross_ref":"contextlib.contextmanager","kind":"Gdef"},"get_module_ns_of":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._namespace_utils.get_module_ns_of","name":"get_module_ns_of","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_module_ns_of","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"ns_for_function":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["obj","parent_namespace"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._namespace_utils.ns_for_function","name":"ns_for_function","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["obj","parent_namespace"],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ns_for_function","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.NamespacesTuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"sys":{".class":"SymbolTableNode","cross_ref":"sys","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_namespace_utils.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_namespace_utils.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_namespace_utils.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..b01628626ca3d81bb92f100aee2b19507a3a0b25 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_namespace_utils.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106714,"dep_lines":[4,1,3,5,6,7,9,1,1,1],"dep_prios":[5,5,10,5,5,5,5,5,30,30],"dependencies":["collections.abc","__future__","sys","contextlib","functools","typing","typing_extensions","builtins","_frozen_importlib","abc"],"hash":"9e000108fafc4524f8c3fdfa60f66050b5f7bb07","id":"pydantic._internal._namespace_utils","ignore_all":true,"interface_hash":"bfd5e81eb3fbc381d899ee2d00bd2295d4b93ceb","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_namespace_utils.py","plugin_data":null,"size":12878,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_repr.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_repr.data.json new file mode 100644 index 0000000000000000000000000000000000000000..a86e045b39ddb6f77e783b21a946b1110352d260 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_repr.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic._internal._repr","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"Collection":{".class":"SymbolTableNode","cross_ref":"typing.Collection","kind":"Gdef"},"ForwardRef":{".class":"SymbolTableNode","cross_ref":"typing.ForwardRef","kind":"Gdef"},"Generator":{".class":"SymbolTableNode","cross_ref":"typing.Generator","kind":"Gdef"},"Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef"},"PlainRepr":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.str"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._repr.PlainRepr","name":"PlainRepr","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._repr.PlainRepr","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic._internal._repr","mro":["pydantic._internal._repr.PlainRepr","builtins.str","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._repr.PlainRepr.__repr__","name":"__repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["pydantic._internal._repr.PlainRepr"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr__ of PlainRepr","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._repr.PlainRepr.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._repr.PlainRepr","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ReprArgs":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic._internal._repr.ReprArgs","name":"ReprArgs","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}}},"Representation":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._repr.Representation","name":"Representation","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._repr.Representation","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic._internal._repr","mro":["pydantic._internal._repr.Representation","builtins.object"],"names":{".class":"SymbolTable","__pretty__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,4],"arg_names":["self","fmt","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._repr.Representation.__pretty__","name":"__pretty__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,4],"arg_names":["self","fmt","kwargs"],"arg_types":["pydantic._internal._repr.Representation",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__pretty__ of Representation","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Generator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._repr.Representation.__repr__","name":"__repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["pydantic._internal._repr.Representation"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr__ of Representation","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr_args__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._repr.Representation.__repr_args__","name":"__repr_args__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._repr.Representation"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr_args__ of Representation","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr_name__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._repr.Representation.__repr_name__","name":"__repr_name__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._repr.Representation"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr_name__ of Representation","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr_recursion__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","object"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._repr.Representation.__repr_recursion__","name":"__repr_recursion__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","object"],"arg_types":["pydantic._internal._repr.Representation",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr_recursion__ of Representation","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr_str__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","join_str"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._repr.Representation.__repr_str__","name":"__repr_str__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","join_str"],"arg_types":["pydantic._internal._repr.Representation","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr_str__ of Representation","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__rich_repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._repr.Representation.__rich_repr__","name":"__rich_repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._repr.Representation"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__rich_repr__ of Representation","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic._internal._repr.Representation.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"__str__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._repr.Representation.__str__","name":"__str__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["pydantic._internal._repr.Representation"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__str__ of Representation","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._repr.Representation.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._repr.Representation","values":[],"variance":0},"slots":[],"tuple_type":null,"type_vars":[],"typeddict_type":null}},"RichReprResult":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic._internal._repr.RichReprResult","name":"RichReprResult","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}}},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"TypeAlias":{".class":"SymbolTableNode","cross_ref":"typing_extensions.TypeAlias","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._repr.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._repr.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._repr.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._repr.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._repr.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._repr.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"_typing_extra":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._typing_extra","kind":"Gdef"},"cast":{".class":"SymbolTableNode","cross_ref":"typing.cast","kind":"Gdef"},"display_as_type":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._repr.display_as_type","name":"display_as_type","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"display_as_type","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_union_origin":{".class":"SymbolTableNode","cross_ref":"typing_inspection.introspection.is_union_origin","kind":"Gdef"},"types":{".class":"SymbolTableNode","cross_ref":"types","kind":"Gdef"},"typing_extensions":{".class":"SymbolTableNode","cross_ref":"typing_extensions","kind":"Gdef"},"typing_objects":{".class":"SymbolTableNode","cross_ref":"typing_inspection.typing_objects","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_repr.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_repr.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_repr.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..99136183159971ba990c6b8f7a4e1013d848915c --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_repr.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[14,6,11,12,14,3,5,7,9,11,1,1,1],"dep_prios":[10,5,10,5,20,5,10,5,5,20,5,30,30],"dependencies":["pydantic._internal._typing_extra","collections.abc","typing_inspection.typing_objects","typing_inspection.introspection","pydantic._internal","__future__","types","typing","typing_extensions","typing_inspection","builtins","_frozen_importlib","abc"],"hash":"dca70427ca55a0cb26d2f0d14ddb6909efb92d89","id":"pydantic._internal._repr","ignore_all":true,"interface_hash":"a313814a6bf1df2605e3a99f1e52866d1a5d5730","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_repr.py","plugin_data":null,"size":5172,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_schema_gather.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_schema_gather.data.json new file mode 100644 index 0000000000000000000000000000000000000000..686c78f97b95579a014ad943ae1c6284312c7378 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_schema_gather.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic._internal._schema_gather","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","AllSchemas":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic._internal._schema_gather.AllSchemas","line":10,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.SerSchema"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.ComputedField"}],"uses_pep604_syntax":true}}},"ComputedField":{".class":"SymbolTableNode","cross_ref":"pydantic_core.core_schema.ComputedField","kind":"Gdef"},"CoreSchema":{".class":"SymbolTableNode","cross_ref":"pydantic_core.core_schema.CoreSchema","kind":"Gdef"},"DefinitionReferenceSchema":{".class":"SymbolTableNode","cross_ref":"pydantic_core.core_schema.DefinitionReferenceSchema","kind":"Gdef"},"GatherContext":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._schema_gather.GatherContext","name":"GatherContext","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._schema_gather.GatherContext","has_param_spec_type":false,"metaclass_type":null,"metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":42,"name":"definitions","type":{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"}],"extra_attrs":null,"type_ref":"builtins.dict"}},{"alias":null,"column":4,"has_default":true,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":45,"name":"deferred_discriminator_schemas","type":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"}],"extra_attrs":null,"type_ref":"builtins.list"}},{"alias":null,"column":4,"has_default":true,"is_in_init":false,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":51,"name":"collected_references","type":{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.DefinitionReferenceSchema"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.dict"}}],"frozen":false},"dataclass_tag":{}},"module_name":"pydantic._internal._schema_gather","mro":["pydantic._internal._schema_gather.GatherContext","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"pydantic._internal._schema_gather.GatherContext.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"dataclasses.Field"}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","definitions"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._schema_gather.GatherContext.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","definitions"],"arg_types":["pydantic._internal._schema_gather.GatherContext",{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of GatherContext","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5],"arg_names":["definitions","deferred_discriminator_schemas","collected_references"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"pydantic._internal._schema_gather.GatherContext.__mypy-replace","name":"__mypy-replace","original_first_arg":"definitions","type":{".class":"CallableType","arg_kinds":[5,5,5],"arg_names":["definitions","deferred_discriminator_schemas","collected_references"],"arg_types":[{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.DefinitionReferenceSchema"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of GatherContext","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"pydantic._internal._schema_gather.GatherContext.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5],"arg_names":["definitions","deferred_discriminator_schemas","collected_references"],"arg_types":[{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.DefinitionReferenceSchema"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of GatherContext","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"collected_references":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic._internal._schema_gather.GatherContext.collected_references","name":"collected_references","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.DefinitionReferenceSchema"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"deferred_discriminator_schemas":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic._internal._schema_gather.GatherContext.deferred_discriminator_schemas","name":"deferred_discriminator_schemas","setter_type":null,"type":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"}],"extra_attrs":null,"type_ref":"builtins.list"}}},"definitions":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic._internal._schema_gather.GatherContext.definitions","name":"definitions","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"}],"extra_attrs":null,"type_ref":"builtins.dict"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._schema_gather.GatherContext.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._schema_gather.GatherContext","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"GatherResult":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._schema_gather.GatherResult","name":"GatherResult","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._schema_gather.GatherResult","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic._internal._schema_gather","mro":["pydantic._internal._schema_gather.GatherResult","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["collected_references",{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.DefinitionReferenceSchema"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.dict"}],["deferred_discriminator_schemas",{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"}],"extra_attrs":null,"type_ref":"builtins.list"}]],"readonly_keys":[],"required_keys":["collected_references","deferred_discriminator_schemas"]}}},"MissingDefinitionError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.LookupError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._schema_gather.MissingDefinitionError","name":"MissingDefinitionError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._schema_gather.MissingDefinitionError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic._internal._schema_gather","mro":["pydantic._internal._schema_gather.MissingDefinitionError","builtins.LookupError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._schema_gather.MissingDefinitionError.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["pydantic._internal._schema_gather.MissingDefinitionError","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of MissingDefinitionError","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"schema_reference":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._schema_gather.MissingDefinitionError.schema_reference","name":"schema_reference","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._schema_gather.MissingDefinitionError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._schema_gather.MissingDefinitionError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"SerSchema":{".class":"SymbolTableNode","cross_ref":"pydantic_core.core_schema.SerSchema","kind":"Gdef"},"TypeAlias":{".class":"SymbolTableNode","cross_ref":"typing_extensions.TypeAlias","kind":"Gdef"},"TypedDict":{".class":"SymbolTableNode","cross_ref":"typing.TypedDict","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._schema_gather.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._schema_gather.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._schema_gather.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._schema_gather.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._schema_gather.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._schema_gather.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"dataclass":{".class":"SymbolTableNode","cross_ref":"dataclasses.dataclass","kind":"Gdef"},"field":{".class":"SymbolTableNode","cross_ref":"dataclasses.field","kind":"Gdef"},"gather_schemas_for_cleaning":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["schema","definitions"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._schema_gather.gather_schemas_for_cleaning","name":"gather_schemas_for_cleaning","original_first_arg":"schema","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["schema","definitions"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"gather_schemas_for_cleaning","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._schema_gather.GatherResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"traverse_definition_ref":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["def_ref_schema","ctx"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._schema_gather.traverse_definition_ref","name":"traverse_definition_ref","original_first_arg":"def_ref_schema","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["def_ref_schema","ctx"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.DefinitionReferenceSchema"},"pydantic._internal._schema_gather.GatherContext"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"traverse_definition_ref","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"traverse_metadata":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["schema","ctx"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._schema_gather.traverse_metadata","name":"traverse_metadata","original_first_arg":"schema","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["schema","ctx"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._schema_gather.AllSchemas"},"pydantic._internal._schema_gather.GatherContext"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"traverse_metadata","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"traverse_schema":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["schema","context"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._schema_gather.traverse_schema","name":"traverse_schema","original_first_arg":"schema","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["schema","context"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._schema_gather.AllSchemas"},"pydantic._internal._schema_gather.GatherContext"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"traverse_schema","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_schema_gather.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_schema_gather.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_schema_gather.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..150cd85d5dd805d5131269f6306620e6e0404f85 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_schema_gather.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[7,2,4,5,8,1,1,1,1,1,1],"dep_prios":[5,5,5,5,5,5,30,30,30,30,30],"dependencies":["pydantic_core.core_schema","__future__","dataclasses","typing","typing_extensions","builtins","_frozen_importlib","_typeshed","abc","enum","pydantic_core"],"hash":"661bb378606670799317dd563fca50d1083d9260","id":"pydantic._internal._schema_gather","ignore_all":true,"interface_hash":"fa5f95eefa812087ea767222846a0b25f843f1fb","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_schema_gather.py","plugin_data":null,"size":9114,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_schema_generation_shared.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_schema_generation_shared.data.json new file mode 100644 index 0000000000000000000000000000000000000000..0fd4e36f988b92755ce712df0e73c1a2e64df3d3 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_schema_generation_shared.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic._internal._schema_generation_shared","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"CallbackGetCoreSchemaHandler":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.annotated_handlers.GetCoreSchemaHandler"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._schema_generation_shared.CallbackGetCoreSchemaHandler","name":"CallbackGetCoreSchemaHandler","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._schema_generation_shared.CallbackGetCoreSchemaHandler","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic._internal._schema_generation_shared","mro":["pydantic._internal._schema_generation_shared.CallbackGetCoreSchemaHandler","pydantic.annotated_handlers.GetCoreSchemaHandler","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._schema_generation_shared.CallbackGetCoreSchemaHandler.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["pydantic._internal._schema_generation_shared.CallbackGetCoreSchemaHandler",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of CallbackGetCoreSchemaHandler","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","handler","generate_schema","ref_mode"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._schema_generation_shared.CallbackGetCoreSchemaHandler.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","handler","generate_schema","ref_mode"],"arg_types":["pydantic._internal._schema_generation_shared.CallbackGetCoreSchemaHandler",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"pydantic._internal._generate_schema.GenerateSchema",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"to-def"},{".class":"LiteralType","fallback":"builtins.str","value":"unpack"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of CallbackGetCoreSchemaHandler","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_generate_schema":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._schema_generation_shared.CallbackGetCoreSchemaHandler._generate_schema","name":"_generate_schema","setter_type":null,"type":"pydantic._internal._generate_schema.GenerateSchema"}},"_get_types_namespace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._schema_generation_shared.CallbackGetCoreSchemaHandler._get_types_namespace","name":"_get_types_namespace","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._schema_generation_shared.CallbackGetCoreSchemaHandler"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_types_namespace of CallbackGetCoreSchemaHandler","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.NamespacesTuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_handler":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._schema_generation_shared.CallbackGetCoreSchemaHandler._handler","name":"_handler","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_ref_mode":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._schema_generation_shared.CallbackGetCoreSchemaHandler._ref_mode","name":"_ref_mode","setter_type":null,"type":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"to-def"},{".class":"LiteralType","fallback":"builtins.str","value":"unpack"}],"uses_pep604_syntax":false}}},"field_name":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"pydantic._internal._schema_generation_shared.CallbackGetCoreSchemaHandler.field_name","name":"field_name","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._schema_generation_shared.CallbackGetCoreSchemaHandler"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"field_name of CallbackGetCoreSchemaHandler","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"pydantic._internal._schema_generation_shared.CallbackGetCoreSchemaHandler.field_name","name":"field_name","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._schema_generation_shared.CallbackGetCoreSchemaHandler"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"field_name of CallbackGetCoreSchemaHandler","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"generate_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._schema_generation_shared.CallbackGetCoreSchemaHandler.generate_schema","name":"generate_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["pydantic._internal._schema_generation_shared.CallbackGetCoreSchemaHandler",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"generate_schema of CallbackGetCoreSchemaHandler","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"resolve_ref_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","maybe_ref_schema"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._schema_generation_shared.CallbackGetCoreSchemaHandler.resolve_ref_schema","name":"resolve_ref_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","maybe_ref_schema"],"arg_types":["pydantic._internal._schema_generation_shared.CallbackGetCoreSchemaHandler",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"resolve_ref_schema of CallbackGetCoreSchemaHandler","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._schema_generation_shared.CallbackGetCoreSchemaHandler.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._schema_generation_shared.CallbackGetCoreSchemaHandler","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"CoreSchemaOrField":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._core_utils.CoreSchemaOrField","kind":"Gdef"},"GenerateJsonSchema":{".class":"SymbolTableNode","cross_ref":"pydantic.json_schema.GenerateJsonSchema","kind":"Gdef"},"GenerateJsonSchemaHandler":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.annotated_handlers.GetJsonSchemaHandler"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._schema_generation_shared.GenerateJsonSchemaHandler","name":"GenerateJsonSchemaHandler","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._schema_generation_shared.GenerateJsonSchemaHandler","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic._internal._schema_generation_shared","mro":["pydantic._internal._schema_generation_shared.GenerateJsonSchemaHandler","pydantic.annotated_handlers.GetJsonSchemaHandler","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._schema_generation_shared.GenerateJsonSchemaHandler.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["pydantic._internal._schema_generation_shared.GenerateJsonSchemaHandler",{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._core_utils.CoreSchemaOrField"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of GenerateJsonSchemaHandler","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.json_schema.JsonSchemaValue"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","generate_json_schema","handler_override"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._schema_generation_shared.GenerateJsonSchemaHandler.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","generate_json_schema","handler_override"],"arg_types":["pydantic._internal._schema_generation_shared.GenerateJsonSchemaHandler","pydantic.json_schema.GenerateJsonSchema",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._schema_generation_shared.HandlerOverride"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of GenerateJsonSchemaHandler","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"generate_json_schema":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._schema_generation_shared.GenerateJsonSchemaHandler.generate_json_schema","name":"generate_json_schema","setter_type":null,"type":"pydantic.json_schema.GenerateJsonSchema"}},"handler":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._schema_generation_shared.GenerateJsonSchemaHandler.handler","name":"handler","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._core_utils.CoreSchemaOrField"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.json_schema.JsonSchemaValue"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"resolve_ref_schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","maybe_ref_json_schema"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._schema_generation_shared.GenerateJsonSchemaHandler.resolve_ref_schema","name":"resolve_ref_schema","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","maybe_ref_json_schema"],"arg_types":["pydantic._internal._schema_generation_shared.GenerateJsonSchemaHandler",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.json_schema.JsonSchemaValue"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"resolve_ref_schema of GenerateJsonSchemaHandler","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.json_schema.JsonSchemaValue"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._schema_generation_shared.GenerateJsonSchemaHandler.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._schema_generation_shared.GenerateJsonSchemaHandler","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"GenerateSchema":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._generate_schema.GenerateSchema","kind":"Gdef"},"GetCoreSchemaHandler":{".class":"SymbolTableNode","cross_ref":"pydantic.annotated_handlers.GetCoreSchemaHandler","kind":"Gdef"},"GetJsonSchemaFunction":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic._internal._schema_generation_shared.GetJsonSchemaFunction","line":17,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._core_utils.CoreSchemaOrField"},"pydantic.annotated_handlers.GetJsonSchemaHandler"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.json_schema.JsonSchemaValue"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"GetJsonSchemaHandler":{".class":"SymbolTableNode","cross_ref":"pydantic.annotated_handlers.GetJsonSchemaHandler","kind":"Gdef"},"HandlerOverride":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic._internal._schema_generation_shared.HandlerOverride","line":18,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._core_utils.CoreSchemaOrField"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.json_schema.JsonSchemaValue"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"JsonSchemaValue":{".class":"SymbolTableNode","cross_ref":"pydantic.json_schema.JsonSchemaValue","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"NamespacesTuple":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._namespace_utils.NamespacesTuple","kind":"Gdef"},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._schema_generation_shared.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._schema_generation_shared.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._schema_generation_shared.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._schema_generation_shared.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._schema_generation_shared.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._schema_generation_shared.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"core_schema":{".class":"SymbolTableNode","cross_ref":"pydantic_core.core_schema","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_schema_generation_shared.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_schema_generation_shared.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_schema_generation_shared.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..427d65a470b6417af7fc824e8df31cbc12c7c5ac --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_schema_generation_shared.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[13,14,15,7,9,12,3,5,7,1,1,1],"dep_prios":[25,25,25,10,5,25,5,5,20,5,30,30],"dependencies":["pydantic._internal._core_utils","pydantic._internal._generate_schema","pydantic._internal._namespace_utils","pydantic_core.core_schema","pydantic.annotated_handlers","pydantic.json_schema","__future__","typing","pydantic_core","builtins","_frozen_importlib","abc"],"hash":"8c4d813e2a8cef18b1bf2f398db489a9a6593890","id":"pydantic._internal._schema_generation_shared","ignore_all":true,"interface_hash":"9d64782ab83182d71ae2d5eb3d8cf0aa2121d112","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_schema_generation_shared.py","plugin_data":null,"size":4842,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_serializers.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_serializers.data.json new file mode 100644 index 0000000000000000000000000000000000000000..092e93dfbee446c37abaf8f360f86998cd3de714 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_serializers.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic._internal._serializers","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"PydanticOmit":{".class":"SymbolTableNode","cross_ref":"pydantic_core._pydantic_core.PydanticOmit","kind":"Gdef"},"SEQUENCE_ORIGIN_MAP":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic._internal._serializers.SEQUENCE_ORIGIN_MAP","name":"SEQUENCE_ORIGIN_MAP","setter_type":null,"type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._serializers.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._serializers.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._serializers.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._serializers.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._serializers.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._serializers.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"collections":{".class":"SymbolTableNode","cross_ref":"collections","kind":"Gdef"},"core_schema":{".class":"SymbolTableNode","cross_ref":"pydantic_core.core_schema","kind":"Gdef"},"serialize_sequence_via_list":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["v","handler","info"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._serializers.serialize_sequence_via_list","name":"serialize_sequence_via_list","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["v","handler","info"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"pydantic_core.core_schema.SerializerFunctionWrapHandler",{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"pydantic_core.core_schema.SerializationInfo"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"serialize_sequence_via_list","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_serializers.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_serializers.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_serializers.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..6ae3d43e89b473ef5a1a0beeb6f825ceca2e6a22 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_serializers.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[4,8,1,3,5,8,1,1,1],"dep_prios":[10,10,5,10,5,5,5,30,30],"dependencies":["collections.abc","pydantic_core.core_schema","__future__","collections","typing","pydantic_core","builtins","_frozen_importlib","abc"],"hash":"bdee6c3664b5d74897459e5a40c63c165e622ec4","id":"pydantic._internal._serializers","ignore_all":true,"interface_hash":"2519c390019580eca613f277f7562658fb1c649a","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_serializers.py","plugin_data":null,"size":1491,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_signature.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_signature.data.json new file mode 100644 index 0000000000000000000000000000000000000000..2b7850184d0c9e17d8493ca84d2b86e7a1b11fa3 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_signature.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic._internal._signature","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"ExtraValues":{".class":"SymbolTableNode","cross_ref":"pydantic.config.ExtraValues","kind":"Gdef"},"FieldInfo":{".class":"SymbolTableNode","cross_ref":"pydantic.fields.FieldInfo","kind":"Gdef"},"Parameter":{".class":"SymbolTableNode","cross_ref":"inspect.Parameter","kind":"Gdef"},"PydanticUndefined":{".class":"SymbolTableNode","cross_ref":"pydantic_core._pydantic_core.PydanticUndefined","kind":"Gdef"},"Signature":{".class":"SymbolTableNode","cross_ref":"inspect.Signature","kind":"Gdef"},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"_HAS_DEFAULT_FACTORY":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._signature._HAS_DEFAULT_FACTORY","name":"_HAS_DEFAULT_FACTORY","setter_type":null,"type":"pydantic._internal._signature._HAS_DEFAULT_FACTORY_CLASS"}},"_HAS_DEFAULT_FACTORY_CLASS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._signature._HAS_DEFAULT_FACTORY_CLASS","name":"_HAS_DEFAULT_FACTORY_CLASS","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._signature._HAS_DEFAULT_FACTORY_CLASS","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic._internal._signature","mro":["pydantic._internal._signature._HAS_DEFAULT_FACTORY_CLASS","builtins.object"],"names":{".class":"SymbolTable","__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._signature._HAS_DEFAULT_FACTORY_CLASS.__repr__","name":"__repr__","original_first_arg":"self","type":null}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._signature._HAS_DEFAULT_FACTORY_CLASS.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._signature._HAS_DEFAULT_FACTORY_CLASS","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._signature.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._signature.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._signature.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._signature.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._signature.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._signature.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_field_name_for_signature":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["field_name","field_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._signature._field_name_for_signature","name":"_field_name_for_signature","original_first_arg":"field_name","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["field_name","field_info"],"arg_types":["builtins.str","pydantic.fields.FieldInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_field_name_for_signature","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_generate_signature_parameters":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["init","fields","validate_by_name","extra"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._signature._generate_signature_parameters","name":"_generate_signature_parameters","original_first_arg":"init","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["init","fields","validate_by_name","extra"],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"Instance","args":["builtins.str","pydantic.fields.FieldInfo"],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.bool",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.config.ExtraValues"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_generate_signature_parameters","ret_type":{".class":"Instance","args":["builtins.str","inspect.Parameter"],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_process_param_defaults":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["param"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._signature._process_param_defaults","name":"_process_param_defaults","original_first_arg":"param","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["param"],"arg_types":["inspect.Parameter"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_process_param_defaults","ret_type":"inspect.Parameter","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"dataclasses":{".class":"SymbolTableNode","cross_ref":"dataclasses","kind":"Gdef"},"generate_pydantic_signature":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1],"arg_names":["init","fields","validate_by_name","extra","is_dataclass"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._signature.generate_pydantic_signature","name":"generate_pydantic_signature","original_first_arg":"init","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["init","fields","validate_by_name","extra","is_dataclass"],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"Instance","args":["builtins.str","pydantic.fields.FieldInfo"],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.bool",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.config.ExtraValues"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"generate_pydantic_signature","ret_type":"inspect.Signature","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_valid_identifier":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._utils.is_valid_identifier","kind":"Gdef"},"signature":{".class":"SymbolTableNode","cross_ref":"inspect.signature","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_signature.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_signature.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_signature.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..00d338195ac3b7bc98cde8b7e6be228285ce43d2 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_signature.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[9,12,13,1,3,4,5,7,1,1,1,1],"dep_prios":[5,25,25,5,10,5,5,5,5,30,30,30],"dependencies":["pydantic._internal._utils","pydantic.config","pydantic.fields","__future__","dataclasses","inspect","typing","pydantic_core","builtins","_frozen_importlib","abc","pydantic._internal._repr"],"hash":"51a318ad6adcd89aba789f7dd2fbf2fed67a1967","id":"pydantic._internal._signature","ignore_all":true,"interface_hash":"7919c683e0f7b753af366c9898dc2808a77b3574","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_signature.py","plugin_data":null,"size":6779,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_typing_extra.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_typing_extra.data.json new file mode 100644 index 0000000000000000000000000000000000000000..649dfdb32765665ca5e0c462df526a62cab0338d --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_typing_extra.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic._internal._typing_extra","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseModel":{".class":"SymbolTableNode","cross_ref":"pydantic.main.BaseModel","kind":"Gdef"},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"EllipsisType":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._typing_extra.EllipsisType","name":"EllipsisType","setter_type":null,"type":{".class":"TypeType","item":"builtins.ellipsis"}}},"GlobalsNamespace":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._namespace_utils.GlobalsNamespace","kind":"Gdef"},"MappingNamespace":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._namespace_utils.MappingNamespace","kind":"Gdef"},"NoneType":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic._internal._typing_extra.NoneType","line":23,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"NoneType"}}},"NsResolver":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._namespace_utils.NsResolver","kind":"Gdef"},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"WithArgsTypes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic._internal._typing_extra.WithArgsTypes","name":"WithArgsTypes","setter_type":null,"type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}}},"_NONE_TYPES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic._internal._typing_extra._NONE_TYPES","name":"_NONE_TYPES","setter_type":null,"type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._typing_extra.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._typing_extra.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._typing_extra.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._typing_extra.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._typing_extra.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._typing_extra.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_classvar_re":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._typing_extra._classvar_re","name":"_classvar_re","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"_eval_type":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["value","globalns","localns","type_params"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._typing_extra._eval_type","name":"_eval_type","original_first_arg":"value","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["value","globalns","localns","type_params"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.GlobalsNamespace"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_eval_type","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_eval_type_backport":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["value","globalns","localns","type_params"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._typing_extra._eval_type_backport","name":"_eval_type_backport","original_first_arg":"value","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["value","globalns","localns","type_params"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.GlobalsNamespace"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_eval_type_backport","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_make_forward_ref":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,5],"arg_names":["arg","is_argument","is_class"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._typing_extra._make_forward_ref","name":"_make_forward_ref","original_first_arg":"arg","type":{".class":"CallableType","arg_kinds":[0,1,5],"arg_names":["arg","is_argument","is_class"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_make_forward_ref","ret_type":"typing.ForwardRef","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_t_annotated":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._typing_extra._t_annotated","name":"_t_annotated","setter_type":null,"type":"typing._SpecialForm"}},"_t_final":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._typing_extra._t_final","name":"_t_final","setter_type":null,"type":"typing._SpecialForm"}},"_te_annotated":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._typing_extra._te_annotated","name":"_te_annotated","setter_type":null,"type":"typing._SpecialForm"}},"_te_final":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._typing_extra._te_final","name":"_te_final","setter_type":null,"type":"typing._SpecialForm"}},"_type_convert":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["arg"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._typing_extra._type_convert","name":"_type_convert","original_first_arg":"arg","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["arg"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_type_convert","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"annotated_type":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._typing_extra.annotated_type","name":"annotated_type","original_first_arg":"tp","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"annotated_type","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"cast":{".class":"SymbolTableNode","cross_ref":"typing.cast","kind":"Gdef"},"collections":{".class":"SymbolTableNode","cross_ref":"collections","kind":"Gdef"},"deprecated":{".class":"SymbolTableNode","cross_ref":"typing_extensions.deprecated","kind":"Gdef"},"eval_type":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["value","globalns","localns"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._typing_extra.eval_type","name":"eval_type","original_first_arg":"value","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["value","globalns","localns"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.GlobalsNamespace"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eval_type","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"eval_type_backport":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["value","globalns","localns","type_params"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._typing_extra.eval_type_backport","name":"eval_type_backport","original_first_arg":"value","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["value","globalns","localns","type_params"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.GlobalsNamespace"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eval_type_backport","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"eval_type_lenient":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["value","globalns","localns"],"dataclass_transform_spec":null,"deprecated":"function pydantic._internal._typing_extra.eval_type_lenient is deprecated: `eval_type_lenient` is deprecated, use `try_eval_type` instead.","flags":["is_decorated"],"fullname":"pydantic._internal._typing_extra.eval_type_lenient","name":"eval_type_lenient","original_first_arg":"value","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["value","globalns","localns"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.GlobalsNamespace"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eval_type_lenient","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._typing_extra.eval_type_lenient","name":"eval_type_lenient","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["value","globalns","localns"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.GlobalsNamespace"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"eval_type_lenient","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"get_args":{".class":"SymbolTableNode","cross_ref":"typing_extensions.get_args","kind":"Gdef"},"get_cls_type_hints":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5],"arg_names":["obj","ns_resolver"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._typing_extra.get_cls_type_hints","name":"get_cls_type_hints","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,5],"arg_names":["obj","ns_resolver"],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},{".class":"UnionType","items":["pydantic._internal._namespace_utils.NsResolver",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_cls_type_hints","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_function_type_hints":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5],"arg_names":["function","include_keys","globalns","localns"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._typing_extra.get_function_type_hints","name":"get_function_type_hints","original_first_arg":"function","type":{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":["function","include_keys","globalns","localns"],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.GlobalsNamespace"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_function_type_hints","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_model_type_hints":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5],"arg_names":["obj","ns_resolver"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._typing_extra.get_model_type_hints","name":"get_model_type_hints","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,5],"arg_names":["obj","ns_resolver"],"arg_types":[{".class":"TypeType","item":"pydantic.main.BaseModel"},{".class":"UnionType","items":["pydantic._internal._namespace_utils.NsResolver",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_model_type_hints","ret_type":{".class":"Instance","args":["builtins.str",{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"builtins.bool"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_module_ns_of":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._namespace_utils.get_module_ns_of","kind":"Gdef"},"get_origin":{".class":"SymbolTableNode","cross_ref":"typing_extensions.get_origin","kind":"Gdef"},"get_type_hints":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["obj","globalns","localns","include_extras"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated"],"fullname":"pydantic._internal._typing_extra.get_type_hints","name":"get_type_hints","original_first_arg":"obj","type":null},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._typing_extra.get_type_hints","name":"get_type_hints","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}}}},"is_annotated":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._typing_extra.is_annotated","name":"is_annotated","original_first_arg":"tp","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_annotated","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_backport_fixable_error":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["e"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._typing_extra.is_backport_fixable_error","name":"is_backport_fixable_error","original_first_arg":"e","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["e"],"arg_types":["builtins.TypeError"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_backport_fixable_error","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_callable":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._typing_extra.is_callable","name":"is_callable","original_first_arg":"tp","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_callable","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_classvar_annotation":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._typing_extra.is_classvar_annotation","name":"is_classvar_annotation","original_first_arg":"tp","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_classvar_annotation","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_finalvar":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._typing_extra.is_finalvar","name":"is_finalvar","original_first_arg":"tp","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_finalvar","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_generic_alias":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._typing_extra.is_generic_alias","name":"is_generic_alias","original_first_arg":"tp","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_generic_alias","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_hashable":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._typing_extra.is_hashable","name":"is_hashable","original_first_arg":"tp","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_hashable","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_namedtuple":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._typing_extra.is_namedtuple","name":"is_namedtuple","original_first_arg":"tp","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_namedtuple","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_none_type":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._typing_extra.is_none_type","name":"is_none_type","original_first_arg":"tp","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_none_type","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_union_origin":{".class":"SymbolTableNode","cross_ref":"typing_inspection.introspection.is_union_origin","kind":"Gdef"},"origin_is_union":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._typing_extra.origin_is_union","name":"origin_is_union","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"parent_frame_namespace":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5],"arg_names":["parent_depth","force"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._typing_extra.parent_frame_namespace","name":"parent_frame_namespace","original_first_arg":"parent_depth","type":{".class":"CallableType","arg_kinds":[5,5],"arg_names":["parent_depth","force"],"arg_types":["builtins.int","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parent_frame_namespace","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"partial":{".class":"SymbolTableNode","cross_ref":"functools.partial","kind":"Gdef"},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef"},"safe_get_annotations":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._typing_extra.safe_get_annotations","name":"safe_get_annotations","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"safe_get_annotations","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"sys":{".class":"SymbolTableNode","cross_ref":"sys","kind":"Gdef"},"try_eval_type":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["value","globalns","localns"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._typing_extra.try_eval_type","name":"try_eval_type","original_first_arg":"value","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["value","globalns","localns"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.GlobalsNamespace"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"try_eval_type","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"builtins.bool"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"types":{".class":"SymbolTableNode","cross_ref":"types","kind":"Gdef"},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef"},"typing_base":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic._internal._typing_extra.typing_base","name":"typing_base","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"typing_extensions":{".class":"SymbolTableNode","cross_ref":"typing_extensions","kind":"Gdef"},"typing_objects":{".class":"SymbolTableNode","cross_ref":"typing_inspection.typing_objects","kind":"Gdef"},"unpack_type":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._typing_extra.unpack_type","name":"unpack_type","original_first_arg":"tp","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unpack_type","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"version_short":{".class":"SymbolTableNode","cross_ref":"pydantic.version.version_short","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_typing_extra.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_typing_extra.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_typing_extra.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..eb9ded34931ceb604a817f7ef2ee93816168f8eb --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_typing_extra.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[20,5,15,16,18,3,5,6,7,8,9,10,13,15,33,1,1,1,1,1,1,1],"dep_prios":[5,10,10,5,5,5,20,10,10,10,5,5,5,20,25,5,30,30,30,30,30,30],"dependencies":["pydantic._internal._namespace_utils","collections.abc","typing_inspection.typing_objects","typing_inspection.introspection","pydantic.version","__future__","collections","re","sys","types","typing","functools","typing_extensions","typing_inspection","pydantic","builtins","_frozen_importlib","_typeshed","abc","enum","pydantic._internal._model_construction","pydantic.main"],"hash":"34189c5965e57c0b02b1c9520bf970f0b5fd7b3f","id":"pydantic._internal._typing_extra","ignore_all":true,"interface_hash":"0f8ce16bd06bc10294069a539a2800eb250bbb99","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_typing_extra.py","plugin_data":null,"size":30309,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_utils.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_utils.data.json new file mode 100644 index 0000000000000000000000000000000000000000..85bcf4aa697eb3e0d5c8e8d631c0d33eb459a655 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_utils.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic._internal._utils","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","AbstractSet":{".class":"SymbolTableNode","cross_ref":"typing.AbstractSet","kind":"Gdef"},"AbstractSetIntStr":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic._internal._utils.AbstractSetIntStr","name":"AbstractSetIntStr","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}}},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BUILTIN_COLLECTIONS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic._internal._utils.BUILTIN_COLLECTIONS","name":"BUILTIN_COLLECTIONS","setter_type":null,"type":{".class":"Instance","args":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"extra_attrs":null,"type_ref":"builtins.set"}}},"BaseModel":{".class":"SymbolTableNode","cross_ref":"pydantic.main.BaseModel","kind":"Gdef"},"BuiltinFunctionType":{".class":"SymbolTableNode","cross_ref":"types.BuiltinFunctionType","kind":"Gdef"},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"CodeType":{".class":"SymbolTableNode","cross_ref":"types.CodeType","kind":"Gdef"},"FunctionType":{".class":"SymbolTableNode","cross_ref":"types.FunctionType","kind":"Gdef"},"GeneratorType":{".class":"SymbolTableNode","cross_ref":"types.GeneratorType","kind":"Gdef"},"Generic":{".class":"SymbolTableNode","cross_ref":"typing.Generic","kind":"Gdef"},"IMMUTABLE_NON_COLLECTIONS_TYPES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic._internal._utils.IMMUTABLE_NON_COLLECTIONS_TYPES","name":"IMMUTABLE_NON_COLLECTIONS_TYPES","setter_type":null,"type":{".class":"Instance","args":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"extra_attrs":null,"type_ref":"builtins.set"}}},"Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef"},"KeyType":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils.KeyType","name":"KeyType","upper_bound":"builtins.object","values":[],"variance":0}},"LambdaType":{".class":"SymbolTableNode","cross_ref":"types.LambdaType","kind":"Gdef"},"LazyClassAttribute":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["name","get_value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_mypy_only"],"fullname":"pydantic._internal._utils.LazyClassAttribute","name":"LazyClassAttribute","original_first_arg":"name","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["name","get_value"],"arg_types":["builtins.str",{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils.T","id":-1,"name":"T","namespace":"pydantic._internal._utils.LazyClassAttribute","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"LazyClassAttribute","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils.T","id":-1,"name":"T","namespace":"pydantic._internal._utils.LazyClassAttribute","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils.T","id":-1,"name":"T","namespace":"pydantic._internal._utils.LazyClassAttribute","upper_bound":"builtins.object","values":[],"variance":0}]}}},"Mapping":{".class":"SymbolTableNode","cross_ref":"typing.Mapping","kind":"Gdef"},"MappingIntStrAny":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic._internal._utils.MappingIntStrAny","name":"MappingIntStrAny","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}}},"ModuleType":{".class":"SymbolTableNode","cross_ref":"types.ModuleType","kind":"Gdef"},"Obj":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils.Obj","name":"Obj","upper_bound":"builtins.object","values":[],"variance":0}},"OrderedDict":{".class":"SymbolTableNode","cross_ref":"collections.OrderedDict","kind":"Gdef"},"Parameter":{".class":"SymbolTableNode","cross_ref":"inspect.Parameter","kind":"Gdef"},"PydanticDeprecatedSince211":{".class":"SymbolTableNode","cross_ref":"pydantic.warnings.PydanticDeprecatedSince211","kind":"Gdef"},"SafeGetItemProxy":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._utils.SafeGetItemProxy","name":"SafeGetItemProxy","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._utils.SafeGetItemProxy","has_param_spec_type":false,"metaclass_type":null,"metadata":{"dataclass":{"attributes":[{"alias":null,"column":4,"has_default":false,"is_in_init":true,"is_init_var":false,"is_neither_frozen_nor_nonfrozen":false,"kw_only":false,"line":388,"name":"wrapped","type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Mapping"}}],"frozen":true},"dataclass_tag":{}},"module_name":"pydantic._internal._utils","mro":["pydantic._internal._utils.SafeGetItemProxy","builtins.object"],"names":{".class":"SymbolTable","__contains__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self","is_mypy_only"],"fullname":"pydantic._internal._utils.SafeGetItemProxy.__contains__","name":"__contains__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["pydantic._internal._utils.SafeGetItemProxy","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__contains__ of SafeGetItemProxy","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"pydantic._internal._utils.SafeGetItemProxy.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"dataclasses.Field"}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__getitem__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._utils.SafeGetItemProxy.__getitem__","name":"__getitem__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["pydantic._internal._utils.SafeGetItemProxy","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of SafeGetItemProxy","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","wrapped"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._utils.SafeGetItemProxy.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","wrapped"],"arg_types":["pydantic._internal._utils.SafeGetItemProxy",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Mapping"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of SafeGetItemProxy","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5],"arg_names":["wrapped"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"pydantic._internal._utils.SafeGetItemProxy.__mypy-replace","name":"__mypy-replace","original_first_arg":"wrapped","type":{".class":"CallableType","arg_kinds":[5],"arg_names":["wrapped"],"arg_types":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Mapping"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of SafeGetItemProxy","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"pydantic._internal._utils.SafeGetItemProxy.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5],"arg_names":["wrapped"],"arg_types":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Mapping"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of SafeGetItemProxy","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic._internal._utils.SafeGetItemProxy.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"wrapped":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready"],"fullname":"pydantic._internal._utils.SafeGetItemProxy.wrapped","name":"wrapped","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Mapping"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils.SafeGetItemProxy.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._utils.SafeGetItemProxy","values":[],"variance":0},"slots":["wrapped"],"tuple_type":null,"type_vars":[],"typeddict_type":null}},"T":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils.T","name":"T","upper_bound":"builtins.object","values":[],"variance":0}},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"TypeAlias":{".class":"SymbolTableNode","cross_ref":"typing_extensions.TypeAlias","kind":"Gdef"},"TypeGuard":{".class":"SymbolTableNode","cross_ref":"typing_extensions.TypeGuard","kind":"Gdef"},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef"},"ValueItems":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic._internal._repr.Representation"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._utils.ValueItems","name":"ValueItems","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._utils.ValueItems","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic._internal._utils","mro":["pydantic._internal._utils.ValueItems","pydantic._internal._repr.Representation","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","value","items"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._utils.ValueItems.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","value","items"],"arg_types":["pydantic._internal._utils.ValueItems",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of ValueItems","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr_args__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._utils.ValueItems.__repr_args__","name":"__repr_args__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._utils.ValueItems"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr_args__ of ValueItems","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic._internal._utils.ValueItems.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_coerce_items":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["items"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"pydantic._internal._utils.ValueItems._coerce_items","name":"_coerce_items","original_first_arg":"items","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["items"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_coerce_items of ValueItems","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_staticmethod","is_ready","is_inferred"],"fullname":"pydantic._internal._utils.ValueItems._coerce_items","name":"_coerce_items","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["items"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":3}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_coerce_items of ValueItems","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":3},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"_coerce_value":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic._internal._utils.ValueItems._coerce_value","name":"_coerce_value","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","value"],"arg_types":[{".class":"TypeType","item":"pydantic._internal._utils.ValueItems"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_coerce_value of ValueItems","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic._internal._utils.ValueItems._coerce_value","name":"_coerce_value","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","value"],"arg_types":[{".class":"TypeType","item":"pydantic._internal._utils.ValueItems"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_coerce_value of ValueItems","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"_items":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic._internal._utils.ValueItems._items","name":"_items","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":3}}},"_normalize_indexes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","items","v_length"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._utils.ValueItems._normalize_indexes","name":"_normalize_indexes","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","items","v_length"],"arg_types":["pydantic._internal._utils.ValueItems",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":3},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_normalize_indexes of ValueItems","ret_type":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":true},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"for_element":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","e"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._utils.ValueItems.for_element","name":"for_element","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","e"],"arg_types":["pydantic._internal._utils.ValueItems",{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"for_element of ValueItems","ret_type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_excluded":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","item"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._utils.ValueItems.is_excluded","name":"is_excluded","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","item"],"arg_types":["pydantic._internal._utils.ValueItems",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_excluded of ValueItems","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_included":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","item"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._utils.ValueItems.is_included","name":"is_included","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","item"],"arg_types":["pydantic._internal._utils.ValueItems",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_included of ValueItems","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_true":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"pydantic._internal._utils.ValueItems.is_true","name":"is_true","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_true of ValueItems","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_staticmethod","is_ready","is_inferred"],"fullname":"pydantic._internal._utils.ValueItems.is_true","name":"is_true","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_true of ValueItems","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"merge":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["cls","base","override","intersect"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic._internal._utils.ValueItems.merge","name":"merge","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["cls","base","override","intersect"],"arg_types":[{".class":"TypeType","item":"pydantic._internal._utils.ValueItems"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"merge of ValueItems","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic._internal._utils.ValueItems.merge","name":"merge","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["cls","base","override","intersect"],"arg_types":[{".class":"TypeType","item":"pydantic._internal._utils.ValueItems"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"merge of ValueItems","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils.ValueItems.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._utils.ValueItems","values":[],"variance":0},"slots":["_items","_type"],"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_ModelT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._ModelT","name":"_ModelT","upper_bound":"pydantic.main.BaseModel","values":[],"variance":0}},"_RT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._RT","name":"_RT","upper_bound":"builtins.object","values":[],"variance":0}},"_SENTINEL":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic._internal._utils._SENTINEL","name":"_SENTINEL","setter_type":null,"type":"builtins.object"}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._utils.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._utils.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._utils.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._utils.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._utils.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._utils.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"_repr":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._repr","kind":"Gdef"},"_typing_extra":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._typing_extra","kind":"Gdef"},"all_identical":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["left","right"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._utils.all_identical","name":"all_identical","original_first_arg":"left","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["left","right"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"all_identical","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"cached_property":{".class":"SymbolTableNode","cross_ref":"functools.cached_property","kind":"Gdef"},"can_be_positional":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["param"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._utils.can_be_positional","name":"can_be_positional","original_first_arg":"param","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["param"],"arg_types":["inspect.Parameter"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"can_be_positional","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"dataclasses":{".class":"SymbolTableNode","cross_ref":"dataclasses","kind":"Gdef"},"deep_update":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2],"arg_names":["mapping","updating_mappings"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._utils.deep_update","name":"deep_update","original_first_arg":"mapping","type":{".class":"CallableType","arg_kinds":[0,2],"arg_names":["mapping","updating_mappings"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils.KeyType","id":-1,"name":"KeyType","namespace":"pydantic._internal._utils.deep_update","upper_bound":"builtins.object","values":[],"variance":0},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils.KeyType","id":-1,"name":"KeyType","namespace":"pydantic._internal._utils.deep_update","upper_bound":"builtins.object","values":[],"variance":0},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"deep_update","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils.KeyType","id":-1,"name":"KeyType","namespace":"pydantic._internal._utils.deep_update","upper_bound":"builtins.object","values":[],"variance":0},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils.KeyType","id":-1,"name":"KeyType","namespace":"pydantic._internal._utils.deep_update","upper_bound":"builtins.object","values":[],"variance":0}]}}},"deepcopy":{".class":"SymbolTableNode","cross_ref":"copy.deepcopy","kind":"Gdef"},"defaultdict":{".class":"SymbolTableNode","cross_ref":"collections.defaultdict","kind":"Gdef"},"deprecated":{".class":"SymbolTableNode","cross_ref":"typing_extensions.deprecated","kind":"Gdef"},"deprecated_instance_property":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._utils.deprecated_instance_property","name":"deprecated_instance_property","type_vars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._ModelT","id":1,"name":"_ModelT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"pydantic.main.BaseModel","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._RT","id":2,"name":"_RT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"builtins.object","values":[],"variance":0}]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._utils.deprecated_instance_property","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic._internal._utils","mro":["pydantic._internal._utils.deprecated_instance_property","builtins.object"],"names":{".class":"SymbolTable","__get__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"pydantic._internal._utils.deprecated_instance_property.__get__","impl":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","instance","objtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_trivial_self"],"fullname":"pydantic._internal._utils.deprecated_instance_property.__get__","name":"__get__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","instance","objtype"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._ModelT","id":1,"name":"_ModelT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"pydantic.main.BaseModel","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._RT","id":2,"name":"_RT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"pydantic._internal._utils.deprecated_instance_property"},{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._ModelT","id":1,"name":"_ModelT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"pydantic.main.BaseModel","values":[],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._ModelT","id":1,"name":"_ModelT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"pydantic.main.BaseModel","values":[],"variance":0}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get__ of deprecated_instance_property","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._RT","id":2,"name":"_RT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","instance","objtype"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"pydantic._internal._utils.deprecated_instance_property.__get__","name":"__get__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","instance","objtype"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._ModelT","id":1,"name":"_ModelT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"pydantic.main.BaseModel","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._RT","id":2,"name":"_RT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"pydantic._internal._utils.deprecated_instance_property"},{".class":"NoneType"},{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._ModelT","id":1,"name":"_ModelT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"pydantic.main.BaseModel","values":[],"variance":0}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get__ of deprecated_instance_property","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._RT","id":2,"name":"_RT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._utils.deprecated_instance_property.__get__","name":"__get__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","instance","objtype"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._ModelT","id":1,"name":"_ModelT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"pydantic.main.BaseModel","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._RT","id":2,"name":"_RT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"pydantic._internal._utils.deprecated_instance_property"},{".class":"NoneType"},{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._ModelT","id":1,"name":"_ModelT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"pydantic.main.BaseModel","values":[],"variance":0}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get__ of deprecated_instance_property","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._RT","id":2,"name":"_RT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","instance","objtype"],"dataclass_transform_spec":null,"deprecated":"overload def (self: pydantic._internal._utils.deprecated_instance_property[_ModelT`1, _RT`2], instance: _ModelT`1, objtype: type[_ModelT`1]) -> _RT`2 of function pydantic._internal._utils.deprecated_instance_property.__get__ is deprecated: Accessing this attribute on the instance is deprecated, and will be removed in Pydantic V3. Instead, you should access this attribute from the model class.","flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"pydantic._internal._utils.deprecated_instance_property.__get__","name":"__get__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","instance","objtype"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._ModelT","id":1,"name":"_ModelT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"pydantic.main.BaseModel","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._RT","id":2,"name":"_RT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"pydantic._internal._utils.deprecated_instance_property"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._ModelT","id":1,"name":"_ModelT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"pydantic.main.BaseModel","values":[],"variance":0},{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._ModelT","id":1,"name":"_ModelT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"pydantic.main.BaseModel","values":[],"variance":0}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get__ of deprecated_instance_property","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._RT","id":2,"name":"_RT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._utils.deprecated_instance_property.__get__","name":"__get__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","instance","objtype"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._ModelT","id":1,"name":"_ModelT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"pydantic.main.BaseModel","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._RT","id":2,"name":"_RT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"pydantic._internal._utils.deprecated_instance_property"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._ModelT","id":1,"name":"_ModelT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"pydantic.main.BaseModel","values":[],"variance":0},{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._ModelT","id":1,"name":"_ModelT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"pydantic.main.BaseModel","values":[],"variance":0}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get__ of deprecated_instance_property","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._RT","id":2,"name":"_RT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","instance","objtype"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._ModelT","id":1,"name":"_ModelT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"pydantic.main.BaseModel","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._RT","id":2,"name":"_RT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"pydantic._internal._utils.deprecated_instance_property"},{".class":"NoneType"},{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._ModelT","id":1,"name":"_ModelT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"pydantic.main.BaseModel","values":[],"variance":0}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get__ of deprecated_instance_property","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._RT","id":2,"name":"_RT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","instance","objtype"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._ModelT","id":1,"name":"_ModelT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"pydantic.main.BaseModel","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._RT","id":2,"name":"_RT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"pydantic._internal._utils.deprecated_instance_property"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._ModelT","id":1,"name":"_ModelT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"pydantic.main.BaseModel","values":[],"variance":0},{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._ModelT","id":1,"name":"_ModelT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"pydantic.main.BaseModel","values":[],"variance":0}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get__ of deprecated_instance_property","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._RT","id":2,"name":"_RT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._utils.deprecated_instance_property.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._ModelT","id":1,"name":"_ModelT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"pydantic.main.BaseModel","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._RT","id":2,"name":"_RT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"pydantic._internal._utils.deprecated_instance_property"},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._ModelT","id":1,"name":"_ModelT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"pydantic.main.BaseModel","values":[],"variance":0}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._RT","id":2,"name":"_RT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of deprecated_instance_property","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"fget":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._utils.deprecated_instance_property.fget","name":"fget","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._ModelT","id":1,"name":"_ModelT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"pydantic.main.BaseModel","values":[],"variance":0}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._RT","id":2,"name":"_RT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils.deprecated_instance_property.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._ModelT","id":1,"name":"_ModelT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"pydantic.main.BaseModel","values":[],"variance":0},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils._RT","id":2,"name":"_RT","namespace":"pydantic._internal._utils.deprecated_instance_property","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"pydantic._internal._utils.deprecated_instance_property"},"values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":["_ModelT","_RT"],"typeddict_type":null}},"deque":{".class":"SymbolTableNode","cross_ref":"collections.deque","kind":"Gdef"},"get_first_not_none":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["a","b"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._utils.get_first_not_none","name":"get_first_not_none","original_first_arg":"a","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["a","b"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_first_not_none","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"import_cached_base_model":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._import_utils.import_cached_base_model","kind":"Gdef"},"is_model_class":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._utils.is_model_class","name":"is_model_class","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_model_class","ret_type":"builtins.bool","type_guard":{".class":"TypeType","item":"pydantic.main.BaseModel"},"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_valid_identifier":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["identifier"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._utils.is_valid_identifier","name":"is_valid_identifier","original_first_arg":"identifier","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["identifier"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_valid_identifier","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"keyword":{".class":"SymbolTableNode","cross_ref":"keyword","kind":"Gdef"},"lenient_isinstance":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["o","class_or_tuple"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._utils.lenient_isinstance","name":"lenient_isinstance","original_first_arg":"o","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["o","class_or_tuple"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},{".class":"Instance","args":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lenient_isinstance","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"lenient_issubclass":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","class_or_tuple"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._utils.lenient_issubclass","name":"lenient_issubclass","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","class_or_tuple"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lenient_issubclass","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef"},"sequence_like":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._utils.sequence_like","name":"sequence_like","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sequence_like","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"smart_deepcopy":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._utils.smart_deepcopy","name":"smart_deepcopy","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils.Obj","id":-1,"name":"Obj","namespace":"pydantic._internal._utils.smart_deepcopy","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"smart_deepcopy","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils.Obj","id":-1,"name":"Obj","namespace":"pydantic._internal._utils.smart_deepcopy","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils.Obj","id":-1,"name":"Obj","namespace":"pydantic._internal._utils.smart_deepcopy","upper_bound":"builtins.object","values":[],"variance":0}]}}},"sys":{".class":"SymbolTableNode","cross_ref":"sys","kind":"Gdef"},"unique_list":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5],"arg_names":["input_list","name_factory"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._utils.unique_list","name":"unique_list","original_first_arg":"input_list","type":{".class":"CallableType","arg_kinds":[0,5],"arg_names":["input_list","name_factory"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils.T","id":-1,"name":"T","namespace":"pydantic._internal._utils.unique_list","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils.T","id":-1,"name":"T","namespace":"pydantic._internal._utils.unique_list","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":true},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils.T","id":-1,"name":"T","namespace":"pydantic._internal._utils.unique_list","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique_list","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils.T","id":-1,"name":"T","namespace":"pydantic._internal._utils.unique_list","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._utils.T","id":-1,"name":"T","namespace":"pydantic._internal._utils.unique_list","upper_bound":"builtins.object","values":[],"variance":0}]}}},"update_not_none":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,4],"arg_names":["mapping","update"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._utils.update_not_none","name":"update_not_none","original_first_arg":"mapping","type":{".class":"CallableType","arg_kinds":[0,4],"arg_names":["mapping","update"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"update_not_none","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"warnings":{".class":"SymbolTableNode","cross_ref":"warnings","kind":"Gdef"},"weakref":{".class":"SymbolTableNode","cross_ref":"weakref","kind":"Gdef"},"zip_longest":{".class":"SymbolTableNode","cross_ref":"itertools.zip_longest","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_utils.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_utils.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_utils.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..c898086966d589e286ec0dab9b75ea927ed27e3b --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_utils.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[27,27,28,14,27,34,6,8,9,10,11,12,13,16,17,18,19,20,21,23,25,1,1,1,1,1],"dep_prios":[10,10,5,5,20,25,5,10,10,10,10,10,5,5,5,5,5,5,5,5,5,5,30,30,30,30],"dependencies":["pydantic._internal._repr","pydantic._internal._typing_extra","pydantic._internal._import_utils","collections.abc","pydantic._internal","pydantic.main","__future__","dataclasses","keyword","sys","warnings","weakref","collections","copy","functools","inspect","itertools","types","typing","typing_extensions","pydantic","builtins","_frozen_importlib","_typeshed","abc","pydantic._internal._model_construction"],"hash":"d0036360fdcc89e380e6aed2dcb70efd86ff4d37","id":"pydantic._internal._utils","ignore_all":true,"interface_hash":"a33922c3c0d776d74b51ed74127106edf075fb73","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_utils.py","plugin_data":null,"size":15799,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_validate_call.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_validate_call.data.json new file mode 100644 index 0000000000000000000000000000000000000000..53b659d9c6894d5028ad9a25ab03361cf34863cd --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_validate_call.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic._internal._validate_call","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"Awaitable":{".class":"SymbolTableNode","cross_ref":"typing.Awaitable","kind":"Gdef"},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"ConfigDict":{".class":"SymbolTableNode","cross_ref":"pydantic.config.ConfigDict","kind":"Gdef"},"ConfigWrapper":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._config.ConfigWrapper","kind":"Gdef"},"GenerateSchema":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._generate_schema.GenerateSchema","kind":"Gdef"},"MappingNamespace":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._namespace_utils.MappingNamespace","kind":"Gdef"},"NsResolver":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._namespace_utils.NsResolver","kind":"Gdef"},"ValidateCallSupportedTypes":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._generate_schema.ValidateCallSupportedTypes","kind":"Gdef"},"ValidateCallWrapper":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic._internal._validate_call.ValidateCallWrapper","name":"ValidateCallWrapper","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic._internal._validate_call.ValidateCallWrapper","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic._internal._validate_call","mro":["pydantic._internal._validate_call.ValidateCallWrapper","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._validate_call.ValidateCallWrapper.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"arg_types":["pydantic._internal._validate_call.ValidateCallWrapper",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of ValidateCallWrapper","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0],"arg_names":["self","function","config","validate_return","parent_namespace"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._validate_call.ValidateCallWrapper.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":["self","function","config","validate_return","parent_namespace"],"arg_types":["pydantic._internal._validate_call.ValidateCallWrapper",{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._generate_schema.ValidateCallSupportedTypes"},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.config.ConfigDict"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._namespace_utils.MappingNamespace"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of ValidateCallWrapper","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__pydantic_complete__":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._validate_call.ValidateCallWrapper.__pydantic_complete__","name":"__pydantic_complete__","setter_type":null,"type":"builtins.bool"}},"__pydantic_validator__":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._validate_call.ValidateCallWrapper.__pydantic_validator__","name":"__pydantic_validator__","setter_type":null,"type":{".class":"UnionType","items":["pydantic_core._pydantic_core.SchemaValidator","pydantic.plugin._schema_validator.PluggableSchemaValidator"],"uses_pep604_syntax":false}}},"__return_pydantic_validator__":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._validate_call.ValidateCallWrapper.__return_pydantic_validator__","name":"__return_pydantic_validator__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["aw"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Awaitable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic._internal._validate_call.ValidateCallWrapper.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_create_validators":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic._internal._validate_call.ValidateCallWrapper._create_validators","name":"_create_validators","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic._internal._validate_call.ValidateCallWrapper"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_create_validators of ValidateCallWrapper","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"config_wrapper":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._validate_call.ValidateCallWrapper.config_wrapper","name":"config_wrapper","setter_type":null,"type":"pydantic._internal._config.ConfigWrapper"}},"function":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._validate_call.ValidateCallWrapper.function","name":"function","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._generate_schema.ValidateCallSupportedTypes"}}},"module":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._validate_call.ValidateCallWrapper.module","name":"module","setter_type":null,"type":"builtins.str"}},"ns_resolver":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._validate_call.ValidateCallWrapper.ns_resolver","name":"ns_resolver","setter_type":null,"type":"pydantic._internal._namespace_utils.NsResolver"}},"qualname":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._validate_call.ValidateCallWrapper.qualname","name":"qualname","setter_type":null,"type":"builtins.str"}},"schema_type":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._validate_call.ValidateCallWrapper.schema_type","name":"schema_type","setter_type":null,"type":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"validate_return":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic._internal._validate_call.ValidateCallWrapper.validate_return","name":"validate_return","setter_type":null,"type":"builtins.bool"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._validate_call.ValidateCallWrapper.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic._internal._validate_call.ValidateCallWrapper","values":[],"variance":0},"slots":["__pydantic_complete__","__pydantic_validator__","__return_pydantic_validator__","config_wrapper","function","module","ns_resolver","qualname","schema_type","validate_return"],"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._validate_call.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._validate_call.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._validate_call.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._validate_call.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._validate_call.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._validate_call.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"create_schema_validator":{".class":"SymbolTableNode","cross_ref":"pydantic.plugin._schema_validator.create_schema_validator","kind":"Gdef"},"extract_function_name":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["func"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._validate_call.extract_function_name","name":"extract_function_name","original_first_arg":"func","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["func"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._generate_schema.ValidateCallSupportedTypes"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"extract_function_name","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"extract_function_qualname":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["func"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._validate_call.extract_function_qualname","name":"extract_function_qualname","original_first_arg":"func","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["func"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._generate_schema.ValidateCallSupportedTypes"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"extract_function_qualname","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"functools":{".class":"SymbolTableNode","cross_ref":"functools","kind":"Gdef"},"inspect":{".class":"SymbolTableNode","cross_ref":"inspect","kind":"Gdef"},"ns_for_function":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._namespace_utils.ns_for_function","kind":"Gdef"},"partial":{".class":"SymbolTableNode","cross_ref":"functools.partial","kind":"Gdef"},"pydantic_core":{".class":"SymbolTableNode","cross_ref":"pydantic_core","kind":"Gdef"},"update_wrapper_attributes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["wrapped","wrapper"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._validate_call.update_wrapper_attributes","name":"update_wrapper_attributes","original_first_arg":"wrapped","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["wrapped","wrapper"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._generate_schema.ValidateCallSupportedTypes"},{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"update_wrapper_attributes","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_validate_call.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_validate_call.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_validate_call.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..0b351229c176b0fa66a71f41f9b0c88c61361810 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_validate_call.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[12,13,14,15,5,11,1,3,4,7,9,1,1,1,1,1,1,1,1,1,1,1],"dep_prios":[5,5,5,5,5,5,5,5,10,5,10,5,30,30,30,30,30,30,30,30,30,30],"dependencies":["pydantic.plugin._schema_validator","pydantic._internal._config","pydantic._internal._generate_schema","pydantic._internal._namespace_utils","collections.abc","pydantic.config","__future__","functools","inspect","typing","pydantic_core","builtins","_frozen_importlib","abc","pydantic._internal._repr","pydantic.aliases","pydantic.fields","pydantic.plugin","pydantic_core._pydantic_core","pydantic_core.core_schema","re","types"],"hash":"054cab769c03ebc3f99db7fa535fecee2ac7df5b","id":"pydantic._internal._validate_call","ignore_all":true,"interface_hash":"50cd0673536e47379c9e143706facad0f9f30238","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_validate_call.py","plugin_data":null,"size":5321,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_validators.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_validators.data.json new file mode 100644 index 0000000000000000000000000000000000000000..481c297d97d82ffe251520aa372a473e7c258210 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_validators.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic._internal._validators","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"Decimal":{".class":"SymbolTableNode","cross_ref":"decimal.Decimal","kind":"Gdef"},"Fraction":{".class":"SymbolTableNode","cross_ref":"fractions.Fraction","kind":"Gdef"},"IP_VALIDATOR_LOOKUP":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic._internal._validators.IP_VALIDATOR_LOOKUP","name":"IP_VALIDATOR_LOOKUP","setter_type":null,"type":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"TypeType","item":"ipaddress.IPv4Address"},{".class":"TypeType","item":"ipaddress.IPv6Address"},{".class":"TypeType","item":"ipaddress.IPv4Network"},{".class":"TypeType","item":"ipaddress.IPv6Network"},{".class":"TypeType","item":"ipaddress.IPv4Interface"},{".class":"TypeType","item":"ipaddress.IPv6Interface"}],"uses_pep604_syntax":false},{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"IPv4Address":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv4Address","kind":"Gdef"},"IPv4Interface":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv4Interface","kind":"Gdef"},"IPv4Network":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv4Network","kind":"Gdef"},"IPv6Address":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv6Address","kind":"Gdef"},"IPv6Interface":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv6Interface","kind":"Gdef"},"IPv6Network":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv6Network","kind":"Gdef"},"IpType":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic._internal._validators.IpType","line":508,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["ipaddress.IPv4Address","ipaddress.IPv6Address","ipaddress.IPv4Network","ipaddress.IPv6Network","ipaddress.IPv4Interface","ipaddress.IPv6Interface"],"uses_pep604_syntax":false}}},"MAPPING_ORIGIN_MAP":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic._internal._validators.MAPPING_ORIGIN_MAP","name":"MAPPING_ORIGIN_MAP","setter_type":null,"type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"NUMERIC_VALIDATOR_LOOKUP":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic._internal._validators.NUMERIC_VALIDATOR_LOOKUP","name":"NUMERIC_VALIDATOR_LOOKUP","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"PatternType":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._validators.PatternType","name":"PatternType","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}},"PydanticCustomError":{".class":"SymbolTableNode","cross_ref":"pydantic_core._pydantic_core.PydanticCustomError","kind":"Gdef"},"PydanticKnownError":{".class":"SymbolTableNode","cross_ref":"pydantic_core._pydantic_core.PydanticKnownError","kind":"Gdef"},"PydanticSchemaGenerationError":{".class":"SymbolTableNode","cross_ref":"pydantic.errors.PydanticSchemaGenerationError","kind":"Gdef"},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef"},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"ZoneInfo":{".class":"SymbolTableNode","cross_ref":"zoneinfo.ZoneInfo","kind":"Gdef"},"ZoneInfoNotFoundError":{".class":"SymbolTableNode","cross_ref":"zoneinfo._common.ZoneInfoNotFoundError","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._validators.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._validators.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._validators.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._validators.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._validators.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic._internal._validators.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"_extract_decimal_digits_info":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["decimal"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._validators._extract_decimal_digits_info","name":"_extract_decimal_digits_info","original_first_arg":"decimal","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["decimal"],"arg_types":["decimal.Decimal"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_extract_decimal_digits_info","ret_type":{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_import_string_logic":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["dotted_path"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._validators._import_string_logic","name":"_import_string_logic","original_first_arg":"dotted_path","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dotted_path"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_import_string_logic","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_safe_repr":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._validators._safe_repr","name":"_safe_repr","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_safe_repr","ret_type":{".class":"UnionType","items":["builtins.int","builtins.float","builtins.str"],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"cast":{".class":"SymbolTableNode","cross_ref":"typing.cast","kind":"Gdef"},"collections":{".class":"SymbolTableNode","cross_ref":"collections","kind":"Gdef"},"compile_pattern":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["pattern"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._validators.compile_pattern","name":"compile_pattern","original_first_arg":"pattern","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["pattern"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._validators.PatternType","id":-1,"name":"PatternType","namespace":"pydantic._internal._validators.compile_pattern","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"compile_pattern","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._validators.PatternType","id":-1,"name":"PatternType","namespace":"pydantic._internal._validators.compile_pattern","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}],"extra_attrs":null,"type_ref":"re.Pattern"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic._internal._validators.PatternType","id":-1,"name":"PatternType","namespace":"pydantic._internal._validators.compile_pattern","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}]}}},"core_schema":{".class":"SymbolTableNode","cross_ref":"pydantic_core.core_schema","kind":"Gdef"},"decimal_places_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x","decimal_places"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._validators.decimal_places_validator","name":"decimal_places_validator","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x","decimal_places"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"decimal_places_validator","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"defaultdict_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["input_value","handler","default_default_factory"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._validators.defaultdict_validator","name":"defaultdict_validator","original_first_arg":"input_value","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["input_value","handler","default_default_factory"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"pydantic_core.core_schema.ValidatorFunctionWrapHandler",{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"defaultdict_validator","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"collections.defaultdict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"deque_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["input_value","handler"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._validators.deque_validator","name":"deque_validator","original_first_arg":"input_value","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["input_value","handler"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"pydantic_core.core_schema.ValidatorFunctionWrapHandler"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"deque_validator","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"collections.deque"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"forbid_inf_nan_check":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["x"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._validators.forbid_inf_nan_check","name":"forbid_inf_nan_check","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["x"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"forbid_inf_nan_check","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"fraction_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._validators.fraction_validator","name":"fraction_validator","original_first_arg":"input_value","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fraction_validator","ret_type":"fractions.Fraction","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_args":{".class":"SymbolTableNode","cross_ref":"typing_extensions.get_args","kind":"Gdef"},"get_defaultdict_default_default_factory":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["values_source_type"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._validators.get_defaultdict_default_default_factory","name":"get_defaultdict_default_default_factory","original_first_arg":"values_source_type","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["values_source_type"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_defaultdict_default_default_factory","ret_type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_origin":{".class":"SymbolTableNode","cross_ref":"typing_extensions.get_origin","kind":"Gdef"},"greater_than_or_equal_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x","ge"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._validators.greater_than_or_equal_validator","name":"greater_than_or_equal_validator","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x","ge"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater_than_or_equal_validator","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"greater_than_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x","gt"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._validators.greater_than_validator","name":"greater_than_validator","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x","gt"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"greater_than_validator","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"import_cached_field_info":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._import_utils.import_cached_field_info","kind":"Gdef"},"import_string":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["value"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._validators.import_string","name":"import_string","original_first_arg":"value","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["value"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"import_string","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"ip_v4_address_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._validators.ip_v4_address_validator","name":"ip_v4_address_validator","original_first_arg":"input_value","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ip_v4_address_validator","ret_type":"ipaddress.IPv4Address","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"ip_v4_interface_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._validators.ip_v4_interface_validator","name":"ip_v4_interface_validator","original_first_arg":"input_value","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ip_v4_interface_validator","ret_type":"ipaddress.IPv4Interface","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"ip_v4_network_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._validators.ip_v4_network_validator","name":"ip_v4_network_validator","original_first_arg":"input_value","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ip_v4_network_validator","ret_type":"ipaddress.IPv4Network","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"ip_v6_address_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._validators.ip_v6_address_validator","name":"ip_v6_address_validator","original_first_arg":"input_value","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ip_v6_address_validator","ret_type":"ipaddress.IPv6Address","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"ip_v6_interface_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._validators.ip_v6_interface_validator","name":"ip_v6_interface_validator","original_first_arg":"input_value","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ip_v6_interface_validator","ret_type":"ipaddress.IPv6Interface","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"ip_v6_network_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._validators.ip_v6_network_validator","name":"ip_v6_network_validator","original_first_arg":"input_value","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ip_v6_network_validator","ret_type":"ipaddress.IPv6Network","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"less_than_or_equal_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x","le"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._validators.less_than_or_equal_validator","name":"less_than_or_equal_validator","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x","le"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less_than_or_equal_validator","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"less_than_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x","lt"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._validators.less_than_validator","name":"less_than_validator","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x","lt"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"less_than_validator","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"math":{".class":"SymbolTableNode","cross_ref":"math","kind":"Gdef"},"max_digits_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x","max_digits"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._validators.max_digits_validator","name":"max_digits_validator","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x","max_digits"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"max_digits_validator","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"max_length_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x","max_length"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._validators.max_length_validator","name":"max_length_validator","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x","max_length"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"max_length_validator","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"min_length_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x","min_length"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._validators.min_length_validator","name":"min_length_validator","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x","min_length"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"min_length_validator","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"multiple_of_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["x","multiple_of"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._validators.multiple_of_validator","name":"multiple_of_validator","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["x","multiple_of"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"multiple_of_validator","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"pattern_bytes_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._validators.pattern_bytes_validator","name":"pattern_bytes_validator","original_first_arg":"input_value","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pattern_bytes_validator","ret_type":{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"re.Pattern"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"pattern_either_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._validators.pattern_either_validator","name":"pattern_either_validator","original_first_arg":"input_value","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pattern_either_validator","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"re.Pattern"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"pattern_str_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._validators.pattern_str_validator","name":"pattern_str_validator","original_first_arg":"input_value","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pattern_str_validator","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef"},"sequence_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,"validator"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._validators.sequence_validator","name":"sequence_validator","original_first_arg":"input_value","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"validator"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Sequence"},"pydantic_core.core_schema.ValidatorFunctionWrapHandler"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sequence_validator","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Sequence"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef"},"typing_extensions":{".class":"SymbolTableNode","cross_ref":"typing_extensions","kind":"Gdef"},"typing_objects":{".class":"SymbolTableNode","cross_ref":"typing_inspection.typing_objects","kind":"Gdef"},"validate_str_is_valid_iana_tz":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic._internal._validators.validate_str_is_valid_iana_tz","name":"validate_str_is_valid_iana_tz","original_first_arg":"value","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate_str_is_valid_iana_tz","ret_type":"zoneinfo.ZoneInfo","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_validators.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_validators.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_validators.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..3e58e8ffabc4139309fdbb34d0ae834ab800436d --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/_internal/_validators.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[24,8,20,22,25,6,8,9,10,11,13,14,15,17,19,20,22,1,1,1,1,1,1],"dep_prios":[5,5,10,10,5,5,20,10,10,5,5,5,5,5,5,5,20,5,30,30,30,30,30],"dependencies":["pydantic._internal._import_utils","collections.abc","pydantic_core.core_schema","typing_inspection.typing_objects","pydantic.errors","__future__","collections","math","re","typing","decimal","fractions","ipaddress","zoneinfo","typing_extensions","pydantic_core","typing_inspection","builtins","_frozen_importlib","_typeshed","abc","datetime","numbers"],"hash":"0e7f8902539f63f34b100778287703ff422dde9b","id":"pydantic._internal._validators","ignore_all":true,"interface_hash":"7f9b7fa5d1c5ad13b72b69460013c694f52494df","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/_internal/_validators.py","plugin_data":null,"size":20588,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..62f1b7ccdaa25d7bd0950ca97e5c955843916116 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic.deprecated","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/deprecated/__init__.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..7a42baf95ed9efed90aae8c5c76b43ddc59aabf4 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106713,"dep_lines":[1,1,1,1],"dep_prios":[5,30,30,30],"dependencies":["builtins","_frozen_importlib","abc","typing"],"hash":"da39a3ee5e6b4b0d3255bfef95601890afd80709","id":"pydantic.deprecated","ignore_all":true,"interface_hash":"74fd5bd394d7bee5473ec0ae05b50d211bda7c9b","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/deprecated/__init__.py","plugin_data":null,"size":0,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/class_validators.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/class_validators.data.json new file mode 100644 index 0000000000000000000000000000000000000000..c3d72829fdaff4474c0c76d075203efac026e399 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/class_validators.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic.deprecated.class_validators","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"FunctionType":{".class":"SymbolTableNode","cross_ref":"types.FunctionType","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"Protocol":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Protocol","kind":"Gdef"},"PydanticDeprecatedSince20":{".class":"SymbolTableNode","cross_ref":"pydantic.warnings.PydanticDeprecatedSince20","kind":"Gdef"},"PydanticUserError":{".class":"SymbolTableNode","cross_ref":"pydantic.errors.PydanticUserError","kind":"Gdef"},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"TypeAlias":{".class":"SymbolTableNode","cross_ref":"typing_extensions.TypeAlias","kind":"Gdef"},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"V1RootValidator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.deprecated.class_validators.V1RootValidator","line":53,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["pydantic.deprecated.class_validators._V1RootValidatorClsMethod","pydantic._internal._decorators_v1.V1RootValidatorFunction"],"uses_pep604_syntax":false}}},"V1Validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.deprecated.class_validators.V1Validator","line":41,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["pydantic.deprecated.class_validators._OnlyValueValidatorClsMethod","pydantic.deprecated.class_validators._V1ValidatorWithValuesClsMethod","pydantic.deprecated.class_validators._V1ValidatorWithValuesKwOnlyClsMethod","pydantic.deprecated.class_validators._V1ValidatorWithKwargsClsMethod","pydantic.deprecated.class_validators._V1ValidatorWithValuesAndKwargsClsMethod","pydantic._internal._decorators_v1.V1ValidatorWithValues","pydantic._internal._decorators_v1.V1ValidatorWithValuesKwOnly","pydantic._internal._decorators_v1.V1ValidatorWithKwargs","pydantic._internal._decorators_v1.V1ValidatorWithValuesAndKwargs"],"uses_pep604_syntax":false}}},"_ALLOW_REUSE_WARNING_MESSAGE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.deprecated.class_validators._ALLOW_REUSE_WARNING_MESSAGE","name":"_ALLOW_REUSE_WARNING_MESSAGE","setter_type":null,"type":"builtins.str"}},"_OnlyValueValidatorClsMethod":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[["__call__",2]],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.deprecated.class_validators._OnlyValueValidatorClsMethod","name":"_OnlyValueValidatorClsMethod","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_abstract","is_protocol"],"fullname":"pydantic.deprecated.class_validators._OnlyValueValidatorClsMethod","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic.deprecated.class_validators","mro":["pydantic.deprecated.class_validators._OnlyValueValidatorClsMethod","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0,0,0],"arg_names":["self",null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_body","is_trivial_self","is_mypy_only"],"fullname":"pydantic.deprecated.class_validators._OnlyValueValidatorClsMethod.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self",null,null],"arg_types":["pydantic.deprecated.class_validators._OnlyValueValidatorClsMethod",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _OnlyValueValidatorClsMethod","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._OnlyValueValidatorClsMethod.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.deprecated.class_validators._OnlyValueValidatorClsMethod","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_PartialClsOrStaticMethod":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.deprecated.class_validators._PartialClsOrStaticMethod","line":58,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.classmethod"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.staticmethod"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"functools.partialmethod"}],"uses_pep604_syntax":false}}},"_V1RootValidatorClsMethod":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[["__call__",2]],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.deprecated.class_validators._V1RootValidatorClsMethod","name":"_V1RootValidatorClsMethod","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_abstract","is_protocol"],"fullname":"pydantic.deprecated.class_validators._V1RootValidatorClsMethod","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic.deprecated.class_validators","mro":["pydantic.deprecated.class_validators._V1RootValidatorClsMethod","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0,0,0],"arg_names":["self",null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_body","is_trivial_self","is_mypy_only"],"fullname":"pydantic.deprecated.class_validators._V1RootValidatorClsMethod.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self",null,null],"arg_types":["pydantic.deprecated.class_validators._V1RootValidatorClsMethod",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._decorators_v1.RootValidatorValues"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _V1RootValidatorClsMethod","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic._internal._decorators_v1.RootValidatorValues"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1RootValidatorClsMethod.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.deprecated.class_validators._V1RootValidatorClsMethod","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_V1RootValidatorFunctionType":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1RootValidatorFunctionType","name":"_V1RootValidatorFunctionType","upper_bound":"builtins.object","values":["pydantic._internal._decorators_v1.V1RootValidatorFunction","pydantic.deprecated.class_validators._V1RootValidatorClsMethod",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators._PartialClsOrStaticMethod"}],"variance":0}},"_V1ValidatorType":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1ValidatorType","name":"_V1ValidatorType","upper_bound":"builtins.object","values":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators.V1Validator"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators._PartialClsOrStaticMethod"}],"variance":0}},"_V1ValidatorWithKwargsClsMethod":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[["__call__",2]],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.deprecated.class_validators._V1ValidatorWithKwargsClsMethod","name":"_V1ValidatorWithKwargsClsMethod","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_abstract","is_protocol"],"fullname":"pydantic.deprecated.class_validators._V1ValidatorWithKwargsClsMethod","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic.deprecated.class_validators","mro":["pydantic.deprecated.class_validators._V1ValidatorWithKwargsClsMethod","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0,0,4],"arg_names":["self",null,"kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_body","is_trivial_self","is_mypy_only"],"fullname":"pydantic.deprecated.class_validators._V1ValidatorWithKwargsClsMethod.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,4],"arg_names":["self",null,"kwargs"],"arg_types":["pydantic.deprecated.class_validators._V1ValidatorWithKwargsClsMethod",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _V1ValidatorWithKwargsClsMethod","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1ValidatorWithKwargsClsMethod.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.deprecated.class_validators._V1ValidatorWithKwargsClsMethod","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_V1ValidatorWithValuesAndKwargsClsMethod":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[["__call__",2]],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.deprecated.class_validators._V1ValidatorWithValuesAndKwargsClsMethod","name":"_V1ValidatorWithValuesAndKwargsClsMethod","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_abstract","is_protocol"],"fullname":"pydantic.deprecated.class_validators._V1ValidatorWithValuesAndKwargsClsMethod","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic.deprecated.class_validators","mro":["pydantic.deprecated.class_validators._V1ValidatorWithValuesAndKwargsClsMethod","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0,0,0,4],"arg_names":["self",null,"values","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_body","is_trivial_self","is_mypy_only"],"fullname":"pydantic.deprecated.class_validators._V1ValidatorWithValuesAndKwargsClsMethod.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,4],"arg_names":["self",null,"values","kwargs"],"arg_types":["pydantic.deprecated.class_validators._V1ValidatorWithValuesAndKwargsClsMethod",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _V1ValidatorWithValuesAndKwargsClsMethod","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1ValidatorWithValuesAndKwargsClsMethod.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.deprecated.class_validators._V1ValidatorWithValuesAndKwargsClsMethod","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_V1ValidatorWithValuesClsMethod":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[["__call__",2]],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.deprecated.class_validators._V1ValidatorWithValuesClsMethod","name":"_V1ValidatorWithValuesClsMethod","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_abstract","is_protocol"],"fullname":"pydantic.deprecated.class_validators._V1ValidatorWithValuesClsMethod","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic.deprecated.class_validators","mro":["pydantic.deprecated.class_validators._V1ValidatorWithValuesClsMethod","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0,0,0,0],"arg_names":["self",null,null,"values"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_body","is_trivial_self","is_mypy_only"],"fullname":"pydantic.deprecated.class_validators._V1ValidatorWithValuesClsMethod.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self",null,null,"values"],"arg_types":["pydantic.deprecated.class_validators._V1ValidatorWithValuesClsMethod",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _V1ValidatorWithValuesClsMethod","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1ValidatorWithValuesClsMethod.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.deprecated.class_validators._V1ValidatorWithValuesClsMethod","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_V1ValidatorWithValuesKwOnlyClsMethod":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[["__call__",2]],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.deprecated.class_validators._V1ValidatorWithValuesKwOnlyClsMethod","name":"_V1ValidatorWithValuesKwOnlyClsMethod","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_abstract","is_protocol"],"fullname":"pydantic.deprecated.class_validators._V1ValidatorWithValuesKwOnlyClsMethod","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic.deprecated.class_validators","mro":["pydantic.deprecated.class_validators._V1ValidatorWithValuesKwOnlyClsMethod","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0,0,0,3],"arg_names":["self",null,null,"values"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_body","is_trivial_self","is_mypy_only"],"fullname":"pydantic.deprecated.class_validators._V1ValidatorWithValuesKwOnlyClsMethod.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,3],"arg_names":["self",null,null,"values"],"arg_types":["pydantic.deprecated.class_validators._V1ValidatorWithValuesKwOnlyClsMethod",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _V1ValidatorWithValuesKwOnlyClsMethod","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1ValidatorWithValuesKwOnlyClsMethod.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.deprecated.class_validators._V1ValidatorWithValuesKwOnlyClsMethod","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.class_validators.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.class_validators.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.class_validators.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.class_validators.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.class_validators.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.class_validators.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"_decorators":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._decorators","kind":"Gdef"},"_decorators_v1":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._decorators_v1","kind":"Gdef"},"deprecated":{".class":"SymbolTableNode","cross_ref":"typing_extensions.deprecated","kind":"Gdef"},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef"},"partial":{".class":"SymbolTableNode","cross_ref":"functools.partial","kind":"Gdef"},"partialmethod":{".class":"SymbolTableNode","cross_ref":"functools.partialmethod","kind":"Gdef"},"root_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":"function pydantic.deprecated.class_validators.root_validator is deprecated: Pydantic V1 style `@root_validator` validators are deprecated. You should migrate to Pydantic V2 style `@model_validator` validators, see the migration guide for more details","flags":[],"fullname":"pydantic.deprecated.class_validators.root_validator","impl":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[2,5,5,5],"arg_names":[null,"pre","skip_on_failure","allow_reuse"],"dataclass_transform_spec":null,"deprecated":"function pydantic.deprecated.class_validators.root_validator is deprecated: Pydantic V1 style `@root_validator` validators are deprecated. You should migrate to Pydantic V2 style `@model_validator` validators, see the migration guide for more details","flags":["is_decorated"],"fullname":"pydantic.deprecated.class_validators.root_validator","name":"root_validator","original_first_arg":"__args","type":{".class":"CallableType","arg_kinds":[2,5,5,5],"arg_names":[null,"pre","skip_on_failure","allow_reuse"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"builtins.bool","builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"root_validator","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.deprecated.class_validators.root_validator","name":"root_validator","setter_type":null,"type":{".class":"CallableType","arg_kinds":[2,5,5,5],"arg_names":[null,"pre","skip_on_failure","allow_reuse"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"builtins.bool","builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"root_validator","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,5],"arg_names":["skip_on_failure","allow_reuse"],"dataclass_transform_spec":null,"deprecated":"function pydantic.deprecated.class_validators.root_validator is deprecated: Pydantic V1 style `@root_validator` validators are deprecated. You should migrate to Pydantic V2 style `@model_validator` validators, see the migration guide for more details","flags":["is_overload","is_decorated"],"fullname":"pydantic.deprecated.class_validators.root_validator","name":"root_validator","original_first_arg":"skip_on_failure","type":{".class":"CallableType","arg_kinds":[3,5],"arg_names":["skip_on_failure","allow_reuse"],"arg_types":[{".class":"LiteralType","fallback":"builtins.bool","value":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"root_validator","ret_type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1RootValidatorFunctionType","id":-1,"name":"_V1RootValidatorFunctionType","namespace":"","upper_bound":"builtins.object","values":["pydantic._internal._decorators_v1.V1RootValidatorFunction","pydantic.deprecated.class_validators._V1RootValidatorClsMethod",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators._PartialClsOrStaticMethod"}],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1RootValidatorFunctionType","id":-1,"name":"_V1RootValidatorFunctionType","namespace":"","upper_bound":"builtins.object","values":["pydantic._internal._decorators_v1.V1RootValidatorFunction","pydantic.deprecated.class_validators._V1RootValidatorClsMethod",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators._PartialClsOrStaticMethod"}],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1RootValidatorFunctionType","id":-1,"name":"_V1RootValidatorFunctionType","namespace":"","upper_bound":"builtins.object","values":["pydantic._internal._decorators_v1.V1RootValidatorFunction","pydantic.deprecated.class_validators._V1RootValidatorClsMethod",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators._PartialClsOrStaticMethod"}],"variance":0}]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.deprecated.class_validators.root_validator","name":"root_validator","setter_type":null,"type":{".class":"CallableType","arg_kinds":[3,5],"arg_names":["skip_on_failure","allow_reuse"],"arg_types":[{".class":"LiteralType","fallback":"builtins.bool","value":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"root_validator","ret_type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1RootValidatorFunctionType","id":-1,"name":"_V1RootValidatorFunctionType","namespace":"","upper_bound":"builtins.object","values":["pydantic._internal._decorators_v1.V1RootValidatorFunction","pydantic.deprecated.class_validators._V1RootValidatorClsMethod",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators._PartialClsOrStaticMethod"}],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1RootValidatorFunctionType","id":-1,"name":"_V1RootValidatorFunctionType","namespace":"","upper_bound":"builtins.object","values":["pydantic._internal._decorators_v1.V1RootValidatorFunction","pydantic.deprecated.class_validators._V1RootValidatorClsMethod",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators._PartialClsOrStaticMethod"}],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1RootValidatorFunctionType","id":-1,"name":"_V1RootValidatorFunctionType","namespace":"","upper_bound":"builtins.object","values":["pydantic._internal._decorators_v1.V1RootValidatorFunction","pydantic.deprecated.class_validators._V1RootValidatorClsMethod",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators._PartialClsOrStaticMethod"}],"variance":0}]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,5],"arg_names":["pre","allow_reuse"],"dataclass_transform_spec":null,"deprecated":"function pydantic.deprecated.class_validators.root_validator is deprecated: Pydantic V1 style `@root_validator` validators are deprecated. You should migrate to Pydantic V2 style `@model_validator` validators, see the migration guide for more details","flags":["is_overload","is_decorated"],"fullname":"pydantic.deprecated.class_validators.root_validator","name":"root_validator","original_first_arg":"pre","type":{".class":"CallableType","arg_kinds":[3,5],"arg_names":["pre","allow_reuse"],"arg_types":[{".class":"LiteralType","fallback":"builtins.bool","value":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"root_validator","ret_type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1RootValidatorFunctionType","id":-1,"name":"_V1RootValidatorFunctionType","namespace":"","upper_bound":"builtins.object","values":["pydantic._internal._decorators_v1.V1RootValidatorFunction","pydantic.deprecated.class_validators._V1RootValidatorClsMethod",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators._PartialClsOrStaticMethod"}],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1RootValidatorFunctionType","id":-1,"name":"_V1RootValidatorFunctionType","namespace":"","upper_bound":"builtins.object","values":["pydantic._internal._decorators_v1.V1RootValidatorFunction","pydantic.deprecated.class_validators._V1RootValidatorClsMethod",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators._PartialClsOrStaticMethod"}],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1RootValidatorFunctionType","id":-1,"name":"_V1RootValidatorFunctionType","namespace":"","upper_bound":"builtins.object","values":["pydantic._internal._decorators_v1.V1RootValidatorFunction","pydantic.deprecated.class_validators._V1RootValidatorClsMethod",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators._PartialClsOrStaticMethod"}],"variance":0}]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.deprecated.class_validators.root_validator","name":"root_validator","setter_type":null,"type":{".class":"CallableType","arg_kinds":[3,5],"arg_names":["pre","allow_reuse"],"arg_types":[{".class":"LiteralType","fallback":"builtins.bool","value":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"root_validator","ret_type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1RootValidatorFunctionType","id":-1,"name":"_V1RootValidatorFunctionType","namespace":"","upper_bound":"builtins.object","values":["pydantic._internal._decorators_v1.V1RootValidatorFunction","pydantic.deprecated.class_validators._V1RootValidatorClsMethod",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators._PartialClsOrStaticMethod"}],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1RootValidatorFunctionType","id":-1,"name":"_V1RootValidatorFunctionType","namespace":"","upper_bound":"builtins.object","values":["pydantic._internal._decorators_v1.V1RootValidatorFunction","pydantic.deprecated.class_validators._V1RootValidatorClsMethod",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators._PartialClsOrStaticMethod"}],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1RootValidatorFunctionType","id":-1,"name":"_V1RootValidatorFunctionType","namespace":"","upper_bound":"builtins.object","values":["pydantic._internal._decorators_v1.V1RootValidatorFunction","pydantic.deprecated.class_validators._V1RootValidatorClsMethod",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators._PartialClsOrStaticMethod"}],"variance":0}]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[3,3,5],"arg_names":["pre","skip_on_failure","allow_reuse"],"dataclass_transform_spec":null,"deprecated":"function pydantic.deprecated.class_validators.root_validator is deprecated: Pydantic V1 style `@root_validator` validators are deprecated. You should migrate to Pydantic V2 style `@model_validator` validators, see the migration guide for more details","flags":["is_overload","is_decorated"],"fullname":"pydantic.deprecated.class_validators.root_validator","name":"root_validator","original_first_arg":"pre","type":{".class":"CallableType","arg_kinds":[3,3,5],"arg_names":["pre","skip_on_failure","allow_reuse"],"arg_types":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"root_validator","ret_type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1RootValidatorFunctionType","id":-1,"name":"_V1RootValidatorFunctionType","namespace":"","upper_bound":"builtins.object","values":["pydantic._internal._decorators_v1.V1RootValidatorFunction","pydantic.deprecated.class_validators._V1RootValidatorClsMethod",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators._PartialClsOrStaticMethod"}],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1RootValidatorFunctionType","id":-1,"name":"_V1RootValidatorFunctionType","namespace":"","upper_bound":"builtins.object","values":["pydantic._internal._decorators_v1.V1RootValidatorFunction","pydantic.deprecated.class_validators._V1RootValidatorClsMethod",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators._PartialClsOrStaticMethod"}],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1RootValidatorFunctionType","id":-1,"name":"_V1RootValidatorFunctionType","namespace":"","upper_bound":"builtins.object","values":["pydantic._internal._decorators_v1.V1RootValidatorFunction","pydantic.deprecated.class_validators._V1RootValidatorClsMethod",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators._PartialClsOrStaticMethod"}],"variance":0}]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.deprecated.class_validators.root_validator","name":"root_validator","setter_type":null,"type":{".class":"CallableType","arg_kinds":[3,3,5],"arg_names":["pre","skip_on_failure","allow_reuse"],"arg_types":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"root_validator","ret_type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1RootValidatorFunctionType","id":-1,"name":"_V1RootValidatorFunctionType","namespace":"","upper_bound":"builtins.object","values":["pydantic._internal._decorators_v1.V1RootValidatorFunction","pydantic.deprecated.class_validators._V1RootValidatorClsMethod",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators._PartialClsOrStaticMethod"}],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1RootValidatorFunctionType","id":-1,"name":"_V1RootValidatorFunctionType","namespace":"","upper_bound":"builtins.object","values":["pydantic._internal._decorators_v1.V1RootValidatorFunction","pydantic.deprecated.class_validators._V1RootValidatorClsMethod",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators._PartialClsOrStaticMethod"}],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1RootValidatorFunctionType","id":-1,"name":"_V1RootValidatorFunctionType","namespace":"","upper_bound":"builtins.object","values":["pydantic._internal._decorators_v1.V1RootValidatorFunction","pydantic.deprecated.class_validators._V1RootValidatorClsMethod",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators._PartialClsOrStaticMethod"}],"variance":0}]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[3,5],"arg_names":["skip_on_failure","allow_reuse"],"arg_types":[{".class":"LiteralType","fallback":"builtins.bool","value":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"root_validator","ret_type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1RootValidatorFunctionType","id":-1,"name":"_V1RootValidatorFunctionType","namespace":"","upper_bound":"builtins.object","values":["pydantic._internal._decorators_v1.V1RootValidatorFunction","pydantic.deprecated.class_validators._V1RootValidatorClsMethod",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators._PartialClsOrStaticMethod"}],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1RootValidatorFunctionType","id":-1,"name":"_V1RootValidatorFunctionType","namespace":"","upper_bound":"builtins.object","values":["pydantic._internal._decorators_v1.V1RootValidatorFunction","pydantic.deprecated.class_validators._V1RootValidatorClsMethod",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators._PartialClsOrStaticMethod"}],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1RootValidatorFunctionType","id":-1,"name":"_V1RootValidatorFunctionType","namespace":"","upper_bound":"builtins.object","values":["pydantic._internal._decorators_v1.V1RootValidatorFunction","pydantic.deprecated.class_validators._V1RootValidatorClsMethod",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators._PartialClsOrStaticMethod"}],"variance":0}]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[3,5],"arg_names":["pre","allow_reuse"],"arg_types":[{".class":"LiteralType","fallback":"builtins.bool","value":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"root_validator","ret_type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1RootValidatorFunctionType","id":-1,"name":"_V1RootValidatorFunctionType","namespace":"","upper_bound":"builtins.object","values":["pydantic._internal._decorators_v1.V1RootValidatorFunction","pydantic.deprecated.class_validators._V1RootValidatorClsMethod",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators._PartialClsOrStaticMethod"}],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1RootValidatorFunctionType","id":-1,"name":"_V1RootValidatorFunctionType","namespace":"","upper_bound":"builtins.object","values":["pydantic._internal._decorators_v1.V1RootValidatorFunction","pydantic.deprecated.class_validators._V1RootValidatorClsMethod",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators._PartialClsOrStaticMethod"}],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1RootValidatorFunctionType","id":-1,"name":"_V1RootValidatorFunctionType","namespace":"","upper_bound":"builtins.object","values":["pydantic._internal._decorators_v1.V1RootValidatorFunction","pydantic.deprecated.class_validators._V1RootValidatorClsMethod",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators._PartialClsOrStaticMethod"}],"variance":0}]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[3,3,5],"arg_names":["pre","skip_on_failure","allow_reuse"],"arg_types":[{".class":"LiteralType","fallback":"builtins.bool","value":false},{".class":"LiteralType","fallback":"builtins.bool","value":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"root_validator","ret_type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1RootValidatorFunctionType","id":-1,"name":"_V1RootValidatorFunctionType","namespace":"","upper_bound":"builtins.object","values":["pydantic._internal._decorators_v1.V1RootValidatorFunction","pydantic.deprecated.class_validators._V1RootValidatorClsMethod",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators._PartialClsOrStaticMethod"}],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1RootValidatorFunctionType","id":-1,"name":"_V1RootValidatorFunctionType","namespace":"","upper_bound":"builtins.object","values":["pydantic._internal._decorators_v1.V1RootValidatorFunction","pydantic.deprecated.class_validators._V1RootValidatorClsMethod",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators._PartialClsOrStaticMethod"}],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1RootValidatorFunctionType","id":-1,"name":"_V1RootValidatorFunctionType","namespace":"","upper_bound":"builtins.object","values":["pydantic._internal._decorators_v1.V1RootValidatorFunction","pydantic.deprecated.class_validators._V1RootValidatorClsMethod",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators._PartialClsOrStaticMethod"}],"variance":0}]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,5,5,5,5,5],"arg_names":[null,"fields","pre","each_item","always","check_fields","allow_reuse"],"dataclass_transform_spec":null,"deprecated":"function pydantic.deprecated.class_validators.validator is deprecated: Pydantic V1 style `@validator` validators are deprecated. You should migrate to Pydantic V2 style `@field_validator` validators, see the migration guide for more details","flags":["is_decorated"],"fullname":"pydantic.deprecated.class_validators.validator","name":"validator","original_first_arg":"__field","type":{".class":"CallableType","arg_kinds":[0,2,5,5,5,5,5],"arg_names":[null,"fields","pre","each_item","always","check_fields","allow_reuse"],"arg_types":["builtins.str","builtins.str","builtins.bool","builtins.bool","builtins.bool",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validator","ret_type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1ValidatorType","id":-1,"name":"_V1ValidatorType","namespace":"","upper_bound":"builtins.object","values":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators.V1Validator"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators._PartialClsOrStaticMethod"}],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1ValidatorType","id":-1,"name":"_V1ValidatorType","namespace":"","upper_bound":"builtins.object","values":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators.V1Validator"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators._PartialClsOrStaticMethod"}],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1ValidatorType","id":-1,"name":"_V1ValidatorType","namespace":"","upper_bound":"builtins.object","values":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators.V1Validator"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators._PartialClsOrStaticMethod"}],"variance":0}]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.deprecated.class_validators.validator","name":"validator","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,2,5,5,5,5,5],"arg_names":[null,"fields","pre","each_item","always","check_fields","allow_reuse"],"arg_types":["builtins.str","builtins.str","builtins.bool","builtins.bool","builtins.bool",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validator","ret_type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1ValidatorType","id":-1,"name":"_V1ValidatorType","namespace":"","upper_bound":"builtins.object","values":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators.V1Validator"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators._PartialClsOrStaticMethod"}],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1ValidatorType","id":-1,"name":"_V1ValidatorType","namespace":"","upper_bound":"builtins.object","values":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators.V1Validator"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators._PartialClsOrStaticMethod"}],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.class_validators._V1ValidatorType","id":-1,"name":"_V1ValidatorType","namespace":"","upper_bound":"builtins.object","values":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators.V1Validator"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.class_validators._PartialClsOrStaticMethod"}],"variance":0}]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"warn":{".class":"SymbolTableNode","cross_ref":"_warnings.warn","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/deprecated/class_validators.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/class_validators.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/class_validators.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..368dae5245749eaa1b13f636f27a0cf046a347d0 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/class_validators.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[12,12,12,13,14,3,5,6,7,8,10,1,1,1],"dep_prios":[10,10,20,5,5,5,5,5,5,5,5,5,30,30],"dependencies":["pydantic._internal._decorators","pydantic._internal._decorators_v1","pydantic._internal","pydantic.errors","pydantic.warnings","__future__","functools","types","typing","warnings","typing_extensions","builtins","_frozen_importlib","abc"],"hash":"4e59dc941ba2a2dd0d1cceedbef13b53aa710804","id":"pydantic.deprecated.class_validators","ignore_all":true,"interface_hash":"af54ef053b6d8af02e8631fcd5ed8df04f5e3b04","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/deprecated/class_validators.py","plugin_data":null,"size":10273,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/config.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/config.data.json new file mode 100644 index 0000000000000000000000000000000000000000..c30c25dc7f3949cdeb4e5f84304bb5eaa65d0107 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/config.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic.deprecated.config","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_public":false},"BaseConfig":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":"pydantic.deprecated.config._ConfigMetaclass","defn":{".class":"ClassDef","fullname":"pydantic.deprecated.config.BaseConfig","name":"BaseConfig","type_vars":[]},"deletable_attributes":[],"deprecated":"class pydantic.deprecated.config.BaseConfig is deprecated: BaseConfig is deprecated. Use the `pydantic.ConfigDict` instead.","flags":[],"fullname":"pydantic.deprecated.config.BaseConfig","has_param_spec_type":false,"metaclass_type":"pydantic.deprecated.config._ConfigMetaclass","metadata":{},"module_name":"pydantic.deprecated.config","mro":["pydantic.deprecated.config.BaseConfig","builtins.object"],"names":{".class":"SymbolTable","__getattr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.deprecated.config.BaseConfig.__getattr__","name":"__getattr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["pydantic.deprecated.config.BaseConfig","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getattr__ of BaseConfig","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init_subclass__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,4],"arg_names":["cls","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_trivial_self"],"fullname":"pydantic.deprecated.config.BaseConfig.__init_subclass__","name":"__init_subclass__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,4],"arg_names":["cls","kwargs"],"arg_types":[{".class":"TypeType","item":"pydantic.deprecated.config.BaseConfig"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init_subclass__ of BaseConfig","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.config.BaseConfig.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.deprecated.config.BaseConfig","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Extra":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":"pydantic.deprecated.config._ExtraMeta","defn":{".class":"ClassDef","fullname":"pydantic.deprecated.config.Extra","name":"Extra","type_vars":[]},"deletable_attributes":[],"deprecated":"class pydantic.deprecated.config.Extra is deprecated: Extra is deprecated. Use literal values instead (e.g. `extra='allow'`)","flags":[],"fullname":"pydantic.deprecated.config.Extra","has_param_spec_type":false,"metaclass_type":"pydantic.deprecated.config._ExtraMeta","metadata":{},"module_name":"pydantic.deprecated.config","mro":["pydantic.deprecated.config.Extra","builtins.object"],"names":{".class":"SymbolTable","allow":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.deprecated.config.Extra.allow","name":"allow","setter_type":null,"type":{".class":"LiteralType","fallback":"builtins.str","value":"allow"}}},"forbid":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.deprecated.config.Extra.forbid","name":"forbid","setter_type":null,"type":{".class":"LiteralType","fallback":"builtins.str","value":"forbid"}}},"ignore":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.deprecated.config.Extra.ignore","name":"ignore","setter_type":null,"type":{".class":"LiteralType","fallback":"builtins.str","value":"ignore"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.config.Extra.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.deprecated.config.Extra","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_public":false},"PydanticDeprecatedSince20":{".class":"SymbolTableNode","cross_ref":"pydantic.warnings.PydanticDeprecatedSince20","kind":"Gdef","module_public":false},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef","module_public":false},"_ConfigMetaclass":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.type"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.deprecated.config._ConfigMetaclass","name":"_ConfigMetaclass","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.deprecated.config._ConfigMetaclass","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.deprecated.config","mro":["pydantic.deprecated.config._ConfigMetaclass","builtins.type","builtins.object"],"names":{".class":"SymbolTable","__getattr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.deprecated.config._ConfigMetaclass.__getattr__","name":"__getattr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["pydantic.deprecated.config._ConfigMetaclass","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getattr__ of _ConfigMetaclass","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.config._ConfigMetaclass.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.deprecated.config._ConfigMetaclass","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_ExtraMeta":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.type"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.deprecated.config._ExtraMeta","name":"_ExtraMeta","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.deprecated.config._ExtraMeta","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.deprecated.config","mro":["pydantic.deprecated.config._ExtraMeta","builtins.type","builtins.object"],"names":{".class":"SymbolTable","__getattribute__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.deprecated.config._ExtraMeta.__getattribute__","name":"__getattribute__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["pydantic.deprecated.config._ExtraMeta","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getattribute__ of _ExtraMeta","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.config._ExtraMeta.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.deprecated.config._ExtraMeta","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.deprecated.config.__all__","name":"__all__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.config.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.config.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.config.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.config.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.config.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.config.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef","module_public":false},"_config":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._config","kind":"Gdef","module_public":false},"deprecated":{".class":"SymbolTableNode","cross_ref":"typing_extensions.deprecated","kind":"Gdef","module_public":false},"warnings":{".class":"SymbolTableNode","cross_ref":"warnings","kind":"Gdef","module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/deprecated/config.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/config.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/config.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..a39b6c4d3a1afc826e56fbdcad0124153ec09633 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/config.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[8,8,9,1,3,4,6,1,1,1],"dep_prios":[10,20,5,5,10,5,5,5,30,30],"dependencies":["pydantic._internal._config","pydantic._internal","pydantic.warnings","__future__","warnings","typing","typing_extensions","builtins","_frozen_importlib","abc"],"hash":"f48eb0b69adaac6686e01eddd666c88d4fc84d2d","id":"pydantic.deprecated.config","ignore_all":true,"interface_hash":"c704134a09a413e8c21ca670bea60240683a09f5","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/deprecated/config.py","plugin_data":null,"size":2663,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/copy_internals.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/copy_internals.data.json new file mode 100644 index 0000000000000000000000000000000000000000..a5bbef44b62de049ac6d60ed367637172d298641 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/copy_internals.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic.deprecated.copy_internals","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","AbstractSetIntStr":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._utils.AbstractSetIntStr","kind":"Gdef"},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"AnyClassMethod":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.deprecated.copy_internals.AnyClassMethod","line":20,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.classmethod"}}},"BaseModel":{".class":"SymbolTableNode","cross_ref":"pydantic.main.BaseModel","kind":"Gdef"},"Enum":{".class":"SymbolTableNode","cross_ref":"enum.Enum","kind":"Gdef"},"IncEx":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.deprecated.copy_internals.IncEx","line":24,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"Instance","args":["builtins.int",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}}},"MappingIntStrAny":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._utils.MappingIntStrAny","kind":"Gdef"},"Model":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.copy_internals.Model","name":"Model","upper_bound":"pydantic.main.BaseModel","values":[],"variance":0}},"TupleGenerator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.deprecated.copy_internals.TupleGenerator","line":21,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Generator"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.copy_internals.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.copy_internals.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.copy_internals.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.copy_internals.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.copy_internals.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.copy_internals.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"_calculate_keys":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1],"arg_names":["self","include","exclude","exclude_unset","update"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.deprecated.copy_internals._calculate_keys","name":"_calculate_keys","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","include","exclude","exclude_unset","update"],"arg_types":["pydantic.main.BaseModel",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_calculate_keys","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.AbstractSet"},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_copy_and_set_values":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1,3],"arg_names":["self","values","fields_set","extra","private","deep"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.deprecated.copy_internals._copy_and_set_values","name":"_copy_and_set_values","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1,3],"arg_names":["self","values","fields_set","extra","private","deep"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.copy_internals.Model","id":-1,"name":"Model","namespace":"pydantic.deprecated.copy_internals._copy_and_set_values","upper_bound":"pydantic.main.BaseModel","values":[],"variance":0},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_copy_and_set_values","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.copy_internals.Model","id":-1,"name":"Model","namespace":"pydantic.deprecated.copy_internals._copy_and_set_values","upper_bound":"pydantic.main.BaseModel","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.copy_internals.Model","id":-1,"name":"Model","namespace":"pydantic.deprecated.copy_internals._copy_and_set_values","upper_bound":"pydantic.main.BaseModel","values":[],"variance":0}]}}},"_get_value":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0,0,0,0,0],"arg_names":["cls","v","to_dict","by_alias","include","exclude","exclude_unset","exclude_defaults","exclude_none"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated"],"fullname":"pydantic.deprecated.copy_internals._get_value","name":"_get_value","original_first_arg":"cls","type":null},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.deprecated.copy_internals._get_value","name":"_get_value","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}}}},"_iter":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1,1],"arg_names":["self","to_dict","by_alias","include","exclude","exclude_unset","exclude_defaults","exclude_none"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.deprecated.copy_internals._iter","name":"_iter","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,1],"arg_names":["self","to_dict","by_alias","include","exclude","exclude_unset","exclude_defaults","exclude_none"],"arg_types":["pydantic.main.BaseModel","builtins.bool","builtins.bool",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":3},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_iter","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.copy_internals.TupleGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_model_construction":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._model_construction","kind":"Gdef"},"_object_setattr":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.deprecated.copy_internals._object_setattr","name":"_object_setattr","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,null,null],"arg_types":["builtins.object","builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_typing_extra":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._typing_extra","kind":"Gdef"},"_utils":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._utils","kind":"Gdef"},"deepcopy":{".class":"SymbolTableNode","cross_ref":"copy.deepcopy","kind":"Gdef"},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef"},"typing_extensions":{".class":"SymbolTableNode","cross_ref":"typing_extensions","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/deprecated/copy_internals.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/copy_internals.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/copy_internals.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..58dad7fd95c917adcb73f74a9b75389c3eb402f1 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/copy_internals.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[10,10,10,10,1,3,4,5,8,17,1,1,1,1],"dep_prios":[10,10,10,20,5,5,5,5,10,25,5,30,30,30],"dependencies":["pydantic._internal._model_construction","pydantic._internal._typing_extra","pydantic._internal._utils","pydantic._internal","__future__","typing","copy","enum","typing_extensions","pydantic","builtins","_frozen_importlib","abc","pydantic.main"],"hash":"3bddb92c92ae98d7b88f4f4d1686eaab1270ab93","id":"pydantic.deprecated.copy_internals","ignore_all":true,"interface_hash":"b17bc3c19130fe7542a76c0d13866108e23792b8","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/deprecated/copy_internals.py","plugin_data":null,"size":7618,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/json.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/json.data.json new file mode 100644 index 0000000000000000000000000000000000000000..8e00d472431fa9a53a849002b129d3aa54d40de7 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/json.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic.deprecated.json","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_public":false},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef","module_public":false},"Color":{".class":"SymbolTableNode","cross_ref":"pydantic.color.Color","kind":"Gdef","module_public":false},"Decimal":{".class":"SymbolTableNode","cross_ref":"decimal.Decimal","kind":"Gdef","module_public":false},"ENCODERS_BY_TYPE":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic.deprecated.json.ENCODERS_BY_TYPE","name":"ENCODERS_BY_TYPE","setter_type":null,"type":{".class":"Instance","args":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"Enum":{".class":"SymbolTableNode","cross_ref":"enum.Enum","kind":"Gdef","module_public":false},"GeneratorType":{".class":"SymbolTableNode","cross_ref":"types.GeneratorType","kind":"Gdef","module_public":false},"IPv4Address":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv4Address","kind":"Gdef","module_public":false},"IPv4Interface":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv4Interface","kind":"Gdef","module_public":false},"IPv4Network":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv4Network","kind":"Gdef","module_public":false},"IPv6Address":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv6Address","kind":"Gdef","module_public":false},"IPv6Interface":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv6Interface","kind":"Gdef","module_public":false},"IPv6Network":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv6Network","kind":"Gdef","module_public":false},"NameEmail":{".class":"SymbolTableNode","cross_ref":"pydantic.networks.NameEmail","kind":"Gdef","module_public":false},"Path":{".class":"SymbolTableNode","cross_ref":"pathlib.Path","kind":"Gdef","module_public":false},"Pattern":{".class":"SymbolTableNode","cross_ref":"re.Pattern","kind":"Gdef","module_public":false},"PydanticDeprecatedSince20":{".class":"SymbolTableNode","cross_ref":"pydantic.warnings.PydanticDeprecatedSince20","kind":"Gdef","module_public":false},"SecretBytes":{".class":"SymbolTableNode","cross_ref":"pydantic.types.SecretBytes","kind":"Gdef","module_public":false},"SecretStr":{".class":"SymbolTableNode","cross_ref":"pydantic.types.SecretStr","kind":"Gdef","module_public":false},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef","module_public":false},"UUID":{".class":"SymbolTableNode","cross_ref":"uuid.UUID","kind":"Gdef","module_public":false},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef","module_public":false},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.deprecated.json.__all__","name":"__all__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.json.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.json.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.json.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.json.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.json.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.json.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"custom_pydantic_encoder":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["type_encoders","obj"],"dataclass_transform_spec":null,"deprecated":"function pydantic.deprecated.json.custom_pydantic_encoder is deprecated: `custom_pydantic_encoder` is deprecated, use `BaseModel.model_dump` instead.","flags":["is_decorated"],"fullname":"pydantic.deprecated.json.custom_pydantic_encoder","name":"custom_pydantic_encoder","original_first_arg":"type_encoders","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["type_encoders","obj"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"custom_pydantic_encoder","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.deprecated.json.custom_pydantic_encoder","name":"custom_pydantic_encoder","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["type_encoders","obj"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"custom_pydantic_encoder","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"datetime":{".class":"SymbolTableNode","cross_ref":"datetime","kind":"Gdef","module_public":false},"decimal_encoder":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["dec_value"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.deprecated.json.decimal_encoder","name":"decimal_encoder","original_first_arg":"dec_value","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dec_value"],"arg_types":["decimal.Decimal"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"decimal_encoder","ret_type":{".class":"UnionType","items":["builtins.int","builtins.float"],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"deprecated":{".class":"SymbolTableNode","cross_ref":"typing_extensions.deprecated","kind":"Gdef","module_public":false},"deque":{".class":"SymbolTableNode","cross_ref":"collections.deque","kind":"Gdef","module_public":false},"import_cached_base_model":{".class":"SymbolTableNode","cross_ref":"pydantic._internal._import_utils.import_cached_base_model","kind":"Gdef","module_public":false},"isoformat":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["o"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.deprecated.json.isoformat","name":"isoformat","original_first_arg":"o","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["o"],"arg_types":[{".class":"UnionType","items":["datetime.date","datetime.time"],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isoformat","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"pydantic_encoder":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":"function pydantic.deprecated.json.pydantic_encoder is deprecated: `pydantic_encoder` is deprecated, use `pydantic_core.to_jsonable_python` instead.","flags":["is_decorated"],"fullname":"pydantic.deprecated.json.pydantic_encoder","name":"pydantic_encoder","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pydantic_encoder","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.deprecated.json.pydantic_encoder","name":"pydantic_encoder","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pydantic_encoder","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"timedelta_isoformat":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["td"],"dataclass_transform_spec":null,"deprecated":"function pydantic.deprecated.json.timedelta_isoformat is deprecated: `timedelta_isoformat` is deprecated.","flags":["is_decorated"],"fullname":"pydantic.deprecated.json.timedelta_isoformat","name":"timedelta_isoformat","original_first_arg":"td","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["td"],"arg_types":["datetime.timedelta"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"timedelta_isoformat","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.deprecated.json.timedelta_isoformat","name":"timedelta_isoformat","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["td"],"arg_types":["datetime.timedelta"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"timedelta_isoformat","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"warnings":{".class":"SymbolTableNode","cross_ref":"warnings","kind":"Gdef","module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/deprecated/json.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/json.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/json.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..bb211711233f507be2dec0d25a954207f44655a7 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/json.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[15,16,17,18,19,1,2,3,4,5,6,7,8,9,10,11,13,1,1,1,1,1,1],"dep_prios":[5,5,5,5,5,10,10,5,5,5,5,5,5,5,5,5,5,5,30,30,30,30,30],"dependencies":["pydantic._internal._import_utils","pydantic.color","pydantic.networks","pydantic.types","pydantic.warnings","datetime","warnings","collections","decimal","enum","ipaddress","pathlib","re","types","typing","uuid","typing_extensions","builtins","_frozen_importlib","abc","os","pydantic._internal","pydantic._internal._repr"],"hash":"128884b0950853091cf546f4036bce88579efa61","id":"pydantic.deprecated.json","ignore_all":true,"interface_hash":"6719acb4e3067225575acbdb3d9010e2e6120a7d","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/deprecated/json.py","plugin_data":null,"size":4657,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/parse.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/parse.data.json new file mode 100644 index 0000000000000000000000000000000000000000..7a13e2b3e9020cfbd8a5ed06065ada24219bc78e --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/parse.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic.deprecated.parse","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"Enum":{".class":"SymbolTableNode","cross_ref":"enum.Enum","kind":"Gdef"},"Path":{".class":"SymbolTableNode","cross_ref":"pathlib.Path","kind":"Gdef"},"Protocol":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.str","enum.Enum"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.deprecated.parse.Protocol","name":"Protocol","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_enum"],"fullname":"pydantic.deprecated.parse.Protocol","has_param_spec_type":false,"metaclass_type":"enum.EnumMeta","metadata":{},"module_name":"pydantic.deprecated.parse","mro":["pydantic.deprecated.parse.Protocol","builtins.str","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","enum.Enum","builtins.object"],"names":{".class":"SymbolTable","json":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.deprecated.parse.Protocol.json","name":"json","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.str","value":"json"},"type_ref":"builtins.str"}}},"pickle":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.deprecated.parse.Protocol.pickle","name":"pickle","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.str","value":"pickle"},"type_ref":"builtins.str"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.parse.Protocol.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.deprecated.parse.Protocol","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"PydanticDeprecatedSince20":{".class":"SymbolTableNode","cross_ref":"pydantic.warnings.PydanticDeprecatedSince20","kind":"Gdef"},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.parse.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.parse.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.parse.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.parse.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.parse.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.parse.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"deprecated":{".class":"SymbolTableNode","cross_ref":"typing_extensions.deprecated","kind":"Gdef"},"json":{".class":"SymbolTableNode","cross_ref":"json","kind":"Gdef"},"load_file":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5,5],"arg_names":["path","content_type","encoding","proto","allow_pickle","json_loads"],"dataclass_transform_spec":null,"deprecated":"function pydantic.deprecated.parse.load_file is deprecated: `load_file` is deprecated.","flags":["is_decorated"],"fullname":"pydantic.deprecated.parse.load_file","name":"load_file","original_first_arg":"path","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5,5],"arg_names":["path","content_type","encoding","proto","allow_pickle","json_loads"],"arg_types":[{".class":"UnionType","items":["builtins.str","pathlib.Path"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str",{".class":"UnionType","items":["pydantic.deprecated.parse.Protocol",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"load_file","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.deprecated.parse.load_file","name":"load_file","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5,5,5,5],"arg_names":["path","content_type","encoding","proto","allow_pickle","json_loads"],"arg_types":[{".class":"UnionType","items":["builtins.str","pathlib.Path"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str",{".class":"UnionType","items":["pydantic.deprecated.parse.Protocol",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"load_file","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"load_str_bytes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5,5],"arg_names":["b","content_type","encoding","proto","allow_pickle","json_loads"],"dataclass_transform_spec":null,"deprecated":"function pydantic.deprecated.parse.load_str_bytes is deprecated: `load_str_bytes` is deprecated.","flags":["is_decorated"],"fullname":"pydantic.deprecated.parse.load_str_bytes","name":"load_str_bytes","original_first_arg":"b","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5,5],"arg_names":["b","content_type","encoding","proto","allow_pickle","json_loads"],"arg_types":[{".class":"UnionType","items":["builtins.str","builtins.bytes"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str",{".class":"UnionType","items":["pydantic.deprecated.parse.Protocol",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"load_str_bytes","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.deprecated.parse.load_str_bytes","name":"load_str_bytes","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5,5,5,5],"arg_names":["b","content_type","encoding","proto","allow_pickle","json_loads"],"arg_types":[{".class":"UnionType","items":["builtins.str","builtins.bytes"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str",{".class":"UnionType","items":["pydantic.deprecated.parse.Protocol",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"load_str_bytes","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"pickle":{".class":"SymbolTableNode","cross_ref":"pickle","kind":"Gdef"},"warnings":{".class":"SymbolTableNode","cross_ref":"warnings","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/deprecated/parse.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/parse.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/parse.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..2a88d95579e412b69db7c9763007cb4de4bad046 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/parse.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[12,1,3,4,5,6,7,8,10,1,1,1,1,1],"dep_prios":[5,5,10,10,10,5,5,5,5,5,30,30,30,30],"dependencies":["pydantic.warnings","__future__","json","pickle","warnings","enum","pathlib","typing","typing_extensions","builtins","_frozen_importlib","abc","json.decoder","os"],"hash":"834f304b8daa8b3cb07e01beaf5872c0c50b28ed","id":"pydantic.deprecated.parse","ignore_all":true,"interface_hash":"9a71cb88aa8c9170be01ee4f77b9cc8883de824c","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/deprecated/parse.py","plugin_data":null,"size":2511,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/tools.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/tools.data.json new file mode 100644 index 0000000000000000000000000000000000000000..f1563a52970ff008590a09651975d6005e484696 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/tools.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic.deprecated.tools","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_public":false},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef","module_public":false},"DEFAULT_REF_TEMPLATE":{".class":"SymbolTableNode","cross_ref":"pydantic.json_schema.DEFAULT_REF_TEMPLATE","kind":"Gdef","module_public":false},"GenerateJsonSchema":{".class":"SymbolTableNode","cross_ref":"pydantic.json_schema.GenerateJsonSchema","kind":"Gdef","module_public":false},"NameFactory":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic.deprecated.tools.NameFactory","line":20,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["builtins.str",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"uses_pep604_syntax":false}}},"PydanticDeprecatedSince20":{".class":"SymbolTableNode","cross_ref":"pydantic.warnings.PydanticDeprecatedSince20","kind":"Gdef","module_public":false},"T":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.tools.T","name":"T","upper_bound":"builtins.object","values":[],"variance":0}},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef","module_public":false},"TypeAdapter":{".class":"SymbolTableNode","cross_ref":"pydantic.type_adapter.TypeAdapter","kind":"Gdef","module_public":false},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_public":false},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef","module_public":false},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.deprecated.tools.__all__","name":"__all__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.tools.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.tools.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.tools.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.tools.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.tools.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.deprecated.tools.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef","module_public":false},"deprecated":{".class":"SymbolTableNode","cross_ref":"typing_extensions.deprecated","kind":"Gdef","module_public":false},"json":{".class":"SymbolTableNode","cross_ref":"json","kind":"Gdef","module_public":false},"parse_obj_as":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["type_","obj","type_name"],"dataclass_transform_spec":null,"deprecated":"function pydantic.deprecated.tools.parse_obj_as is deprecated: `parse_obj_as` is deprecated. Use `pydantic.TypeAdapter.validate_python` instead.","flags":["is_decorated"],"fullname":"pydantic.deprecated.tools.parse_obj_as","name":"parse_obj_as","original_first_arg":"type_","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["type_","obj","type_name"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.tools.T","id":-1,"name":"T","namespace":"pydantic.deprecated.tools.parse_obj_as","upper_bound":"builtins.object","values":[],"variance":0}},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.tools.NameFactory"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parse_obj_as","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.tools.T","id":-1,"name":"T","namespace":"pydantic.deprecated.tools.parse_obj_as","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.tools.T","id":-1,"name":"T","namespace":"pydantic.deprecated.tools.parse_obj_as","upper_bound":"builtins.object","values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.deprecated.tools.parse_obj_as","name":"parse_obj_as","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["type_","obj","type_name"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.tools.T","id":-1,"name":"T","namespace":"pydantic.deprecated.tools.parse_obj_as","upper_bound":"builtins.object","values":[],"variance":0}},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.tools.NameFactory"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parse_obj_as","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.tools.T","id":-1,"name":"T","namespace":"pydantic.deprecated.tools.parse_obj_as","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.deprecated.tools.T","id":-1,"name":"T","namespace":"pydantic.deprecated.tools.parse_obj_as","upper_bound":"builtins.object","values":[],"variance":0}]}}}},"schema_json_of":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5,4],"arg_names":["type_","title","by_alias","ref_template","schema_generator","dumps_kwargs"],"dataclass_transform_spec":null,"deprecated":"function pydantic.deprecated.tools.schema_json_of is deprecated: `schema_json_of` is deprecated. Use `pydantic.TypeAdapter.json_schema` instead.","flags":["is_decorated"],"fullname":"pydantic.deprecated.tools.schema_json_of","name":"schema_json_of","original_first_arg":"type_","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5,4],"arg_names":["type_","title","by_alias","ref_template","schema_generator","dumps_kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.tools.NameFactory"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.str",{".class":"TypeType","item":"pydantic.json_schema.GenerateJsonSchema"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"schema_json_of","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.deprecated.tools.schema_json_of","name":"schema_json_of","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5,5,5,4],"arg_names":["type_","title","by_alias","ref_template","schema_generator","dumps_kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.tools.NameFactory"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.str",{".class":"TypeType","item":"pydantic.json_schema.GenerateJsonSchema"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"schema_json_of","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"schema_of":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5],"arg_names":["type_","title","by_alias","ref_template","schema_generator"],"dataclass_transform_spec":null,"deprecated":"function pydantic.deprecated.tools.schema_of is deprecated: `schema_of` is deprecated. Use `pydantic.TypeAdapter.json_schema` instead.","flags":["is_decorated"],"fullname":"pydantic.deprecated.tools.schema_of","name":"schema_of","original_first_arg":"type_","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":["type_","title","by_alias","ref_template","schema_generator"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.tools.NameFactory"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.str",{".class":"TypeType","item":"pydantic.json_schema.GenerateJsonSchema"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"schema_of","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.deprecated.tools.schema_of","name":"schema_of","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":["type_","title","by_alias","ref_template","schema_generator"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.deprecated.tools.NameFactory"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool","builtins.str",{".class":"TypeType","item":"pydantic.json_schema.GenerateJsonSchema"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"schema_of","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"warnings":{".class":"SymbolTableNode","cross_ref":"warnings","kind":"Gdef","module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/deprecated/tools.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/tools.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/tools.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..45fc9a24f9f606c5cfa4049d377eeff997652ca0 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/deprecated/tools.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[9,10,11,1,3,4,5,7,1,1,1],"dep_prios":[5,5,5,5,10,10,5,5,5,30,30],"dependencies":["pydantic.json_schema","pydantic.type_adapter","pydantic.warnings","__future__","json","warnings","typing","typing_extensions","builtins","_frozen_importlib","abc"],"hash":"97d986de9165a54fc5a9e0ca37bfe34a496fd7bc","id":"pydantic.deprecated.tools","ignore_all":true,"interface_hash":"f43fc5d1bd5c60281288ea8ba6483183ba07bcfd","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/deprecated/tools.py","plugin_data":null,"size":3330,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/plugin/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/plugin/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..092c719ad22aa9c1a16c4d44421d6de98bac105b --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/plugin/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic.plugin","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_public":false},"BaseValidateHandlerProtocol":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[["on_enter",1]],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.plugin.BaseValidateHandlerProtocol","name":"BaseValidateHandlerProtocol","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_abstract","is_protocol"],"fullname":"pydantic.plugin.BaseValidateHandlerProtocol","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic.plugin","mro":["pydantic.plugin.BaseValidateHandlerProtocol","builtins.object"],"names":{".class":"SymbolTable","on_enter":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_abstract_var","is_ready"],"fullname":"pydantic.plugin.BaseValidateHandlerProtocol.on_enter","name":"on_enter","setter_type":null,"type":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"on_error":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","error"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.plugin.BaseValidateHandlerProtocol.on_error","name":"on_error","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","error"],"arg_types":["pydantic.plugin.BaseValidateHandlerProtocol","pydantic_core._pydantic_core.ValidationError"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"on_error of BaseValidateHandlerProtocol","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"on_exception":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","exception"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.plugin.BaseValidateHandlerProtocol.on_exception","name":"on_exception","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","exception"],"arg_types":["pydantic.plugin.BaseValidateHandlerProtocol","builtins.Exception"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"on_exception of BaseValidateHandlerProtocol","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"on_success":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","result"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.plugin.BaseValidateHandlerProtocol.on_success","name":"on_success","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","result"],"arg_types":["pydantic.plugin.BaseValidateHandlerProtocol",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"on_success of BaseValidateHandlerProtocol","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.plugin.BaseValidateHandlerProtocol.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.plugin.BaseValidateHandlerProtocol","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef","module_public":false},"CoreConfig":{".class":"SymbolTableNode","cross_ref":"pydantic_core.core_schema.CoreConfig","kind":"Gdef","module_public":false},"CoreSchema":{".class":"SymbolTableNode","cross_ref":"pydantic_core.core_schema.CoreSchema","kind":"Gdef","module_public":false},"ExtraValues":{".class":"SymbolTableNode","cross_ref":"pydantic.config.ExtraValues","kind":"Gdef","module_public":false},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef","module_public":false},"NamedTuple":{".class":"SymbolTableNode","cross_ref":"typing.NamedTuple","kind":"Gdef","module_public":false},"NewSchemaReturns":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic.plugin.NewSchemaReturns","line":27,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["pydantic.plugin.ValidatePythonHandlerProtocol",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["pydantic.plugin.ValidateJsonHandlerProtocol",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["pydantic.plugin.ValidateStringsHandlerProtocol",{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"Protocol":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Protocol","kind":"Gdef","module_public":false},"PydanticPluginProtocol":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[["new_schema_validator",2]],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.plugin.PydanticPluginProtocol","name":"PydanticPluginProtocol","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_abstract","is_protocol"],"fullname":"pydantic.plugin.PydanticPluginProtocol","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic.plugin","mro":["pydantic.plugin.PydanticPluginProtocol","builtins.object"],"names":{".class":"SymbolTable","new_schema_validator":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0,0,0,0,0,0,0],"arg_names":["self","schema","schema_type","schema_type_path","schema_kind","config","plugin_settings"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_body","is_trivial_self"],"fullname":"pydantic.plugin.PydanticPluginProtocol.new_schema_validator","name":"new_schema_validator","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,0],"arg_names":["self","schema","schema_type","schema_type_path","schema_kind","config","plugin_settings"],"arg_types":["pydantic.plugin.PydanticPluginProtocol",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.plugin.SchemaTypePath"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.plugin.SchemaKind"},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreConfig"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"Instance","args":["builtins.str","builtins.object"],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"new_schema_validator of PydanticPluginProtocol","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["pydantic.plugin.ValidatePythonHandlerProtocol",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["pydantic.plugin.ValidateJsonHandlerProtocol",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["pydantic.plugin.ValidateStringsHandlerProtocol",{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.plugin.PydanticPluginProtocol.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.plugin.PydanticPluginProtocol","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"SchemaKind":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic.plugin.SchemaKind","line":37,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"BaseModel"},{".class":"LiteralType","fallback":"builtins.str","value":"TypeAdapter"},{".class":"LiteralType","fallback":"builtins.str","value":"dataclass"},{".class":"LiteralType","fallback":"builtins.str","value":"create_model"},{".class":"LiteralType","fallback":"builtins.str","value":"validate_call"}],"uses_pep604_syntax":false}}},"SchemaTypePath":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.plugin.SchemaTypePath","name":"SchemaTypePath","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_named_tuple"],"fullname":"pydantic.plugin.SchemaTypePath","has_param_spec_type":false,"metaclass_type":null,"metadata":{"namedtuple":{"fields":["module","name"]}},"module_name":"pydantic.plugin","mro":["pydantic.plugin.SchemaTypePath","builtins.tuple","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","_NT":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.plugin.SchemaTypePath._NT","name":"_NT","upper_bound":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},"__annotations__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic.plugin.SchemaTypePath.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic.plugin.SchemaTypePath.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__new__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["_cls","module","name"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static"],"fullname":"pydantic.plugin.SchemaTypePath.__new__","name":"__new__","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["_cls","module","name"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.plugin.SchemaTypePath._NT","id":-1,"name":"_NT","namespace":"pydantic.plugin.SchemaTypePath.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},"builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of SchemaTypePath","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.plugin.SchemaTypePath._NT","id":-1,"name":"_NT","namespace":"pydantic.plugin.SchemaTypePath.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.plugin.SchemaTypePath._NT","id":-1,"name":"_NT","namespace":"pydantic.plugin.SchemaTypePath.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_asdict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["_self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.plugin.SchemaTypePath._asdict","name":"_asdict","original_first_arg":"_self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["_self"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.plugin.SchemaTypePath._NT","id":-1,"name":"_NT","namespace":"pydantic.plugin.SchemaTypePath._asdict","upper_bound":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_asdict of SchemaTypePath","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.plugin.SchemaTypePath._NT","id":-1,"name":"_NT","namespace":"pydantic.plugin.SchemaTypePath._asdict","upper_bound":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_field_defaults":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic.plugin.SchemaTypePath._field_defaults","name":"_field_defaults","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_field_types":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic.plugin.SchemaTypePath._field_types","name":"_field_types","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_fields":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic.plugin.SchemaTypePath._fields","name":"_fields","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_make":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["_cls","iterable"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated"],"fullname":"pydantic.plugin.SchemaTypePath._make","name":"_make","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["_cls","iterable"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.plugin.SchemaTypePath._NT","id":-1,"name":"_NT","namespace":"pydantic.plugin.SchemaTypePath._make","upper_bound":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_make of SchemaTypePath","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.plugin.SchemaTypePath._NT","id":-1,"name":"_NT","namespace":"pydantic.plugin.SchemaTypePath._make","upper_bound":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.plugin.SchemaTypePath._NT","id":-1,"name":"_NT","namespace":"pydantic.plugin.SchemaTypePath._make","upper_bound":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_classmethod","is_ready"],"fullname":"pydantic.plugin.SchemaTypePath._make","name":"_make","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["_cls","iterable"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.plugin.SchemaTypePath._NT","id":-1,"name":"_NT","namespace":"pydantic.plugin.SchemaTypePath._make","upper_bound":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_make of SchemaTypePath","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.plugin.SchemaTypePath._NT","id":-1,"name":"_NT","namespace":"pydantic.plugin.SchemaTypePath._make","upper_bound":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.plugin.SchemaTypePath._NT","id":-1,"name":"_NT","namespace":"pydantic.plugin.SchemaTypePath._make","upper_bound":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}}},"plugin_generated":true},"_replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5],"arg_names":["_self","module","name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.plugin.SchemaTypePath._replace","name":"_replace","original_first_arg":"_self","type":{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":["_self","module","name"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.plugin.SchemaTypePath._NT","id":-1,"name":"_NT","namespace":"pydantic.plugin.SchemaTypePath._replace","upper_bound":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_replace of SchemaTypePath","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.plugin.SchemaTypePath._NT","id":-1,"name":"_NT","namespace":"pydantic.plugin.SchemaTypePath._replace","upper_bound":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.plugin.SchemaTypePath._NT","id":-1,"name":"_NT","namespace":"pydantic.plugin.SchemaTypePath._replace","upper_bound":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_source":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic.plugin.SchemaTypePath._source","name":"_source","setter_type":null,"type":"builtins.str"}},"module":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"pydantic.plugin.SchemaTypePath.module","name":"module","setter_type":null,"type":"builtins.str"}},"module-redefinition":{".class":"SymbolTableNode","cross_ref":"pydantic.plugin.SchemaTypePath.module","kind":"Mdef"},"name":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"pydantic.plugin.SchemaTypePath.name","name":"name","setter_type":null,"type":"builtins.str"}},"name-redefinition":{".class":"SymbolTableNode","cross_ref":"pydantic.plugin.SchemaTypePath.name","kind":"Mdef"}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.plugin.SchemaTypePath.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":"pydantic.plugin.SchemaTypePath"},"values":[],"variance":0},"slots":null,"tuple_type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_vars":[],"typeddict_type":null}},"StringInput":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic.plugin.StringInput","line":168,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.plugin.StringInput"}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"TypeAlias":{".class":"SymbolTableNode","cross_ref":"typing_extensions.TypeAlias","kind":"Gdef","module_public":false},"ValidateJsonHandlerProtocol":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[["on_enter",2]],"alt_promote":null,"bases":["pydantic.plugin.BaseValidateHandlerProtocol"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.plugin.ValidateJsonHandlerProtocol","name":"ValidateJsonHandlerProtocol","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_abstract","is_protocol"],"fullname":"pydantic.plugin.ValidateJsonHandlerProtocol","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic.plugin","mro":["pydantic.plugin.ValidateJsonHandlerProtocol","pydantic.plugin.BaseValidateHandlerProtocol","builtins.object"],"names":{".class":"SymbolTable","on_enter":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0,0,5,5,5,5,5,5],"arg_names":["self","input","strict","extra","context","self_instance","by_alias","by_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_body","is_trivial_self"],"fullname":"pydantic.plugin.ValidateJsonHandlerProtocol.on_enter","name":"on_enter","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5],"arg_names":["self","input","strict","extra","context","self_instance","by_alias","by_name"],"arg_types":["pydantic.plugin.ValidateJsonHandlerProtocol",{".class":"UnionType","items":["builtins.str","builtins.bytes","builtins.bytearray"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.config.ExtraValues"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"on_enter of ValidateJsonHandlerProtocol","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.plugin.ValidateJsonHandlerProtocol.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.plugin.ValidateJsonHandlerProtocol","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ValidatePythonHandlerProtocol":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[["on_enter",2]],"alt_promote":null,"bases":["pydantic.plugin.BaseValidateHandlerProtocol"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.plugin.ValidatePythonHandlerProtocol","name":"ValidatePythonHandlerProtocol","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_abstract","is_protocol"],"fullname":"pydantic.plugin.ValidatePythonHandlerProtocol","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic.plugin","mro":["pydantic.plugin.ValidatePythonHandlerProtocol","pydantic.plugin.BaseValidateHandlerProtocol","builtins.object"],"names":{".class":"SymbolTable","on_enter":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0,0,5,5,5,5,5,5,5],"arg_names":["self","input","strict","extra","from_attributes","context","self_instance","by_alias","by_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_body","is_trivial_self"],"fullname":"pydantic.plugin.ValidatePythonHandlerProtocol.on_enter","name":"on_enter","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5,5],"arg_names":["self","input","strict","extra","from_attributes","context","self_instance","by_alias","by_name"],"arg_types":["pydantic.plugin.ValidatePythonHandlerProtocol",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.config.ExtraValues"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"on_enter of ValidatePythonHandlerProtocol","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.plugin.ValidatePythonHandlerProtocol.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.plugin.ValidatePythonHandlerProtocol","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ValidateStringsHandlerProtocol":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[["on_enter",2]],"alt_promote":null,"bases":["pydantic.plugin.BaseValidateHandlerProtocol"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.plugin.ValidateStringsHandlerProtocol","name":"ValidateStringsHandlerProtocol","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_abstract","is_protocol"],"fullname":"pydantic.plugin.ValidateStringsHandlerProtocol","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic.plugin","mro":["pydantic.plugin.ValidateStringsHandlerProtocol","pydantic.plugin.BaseValidateHandlerProtocol","builtins.object"],"names":{".class":"SymbolTable","on_enter":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0,0,5,5,5,5,5],"arg_names":["self","input","strict","extra","context","by_alias","by_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_body","is_trivial_self"],"fullname":"pydantic.plugin.ValidateStringsHandlerProtocol.on_enter","name":"on_enter","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5],"arg_names":["self","input","strict","extra","context","by_alias","by_name"],"arg_types":["pydantic.plugin.ValidateStringsHandlerProtocol",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.plugin.StringInput"},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.config.ExtraValues"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"on_enter of ValidateStringsHandlerProtocol","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.plugin.ValidateStringsHandlerProtocol.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.plugin.ValidateStringsHandlerProtocol","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ValidationError":{".class":"SymbolTableNode","cross_ref":"pydantic_core._pydantic_core.ValidationError","kind":"Gdef","module_public":false},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.plugin.__all__","name":"__all__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.plugin.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.plugin.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.plugin.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.plugin.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.plugin.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.plugin.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.plugin.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef","module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/plugin/__init__.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/plugin/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/plugin/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..d3be7d766b1a5bbaeb73c868361f706455050be7 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/plugin/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[14,7,9,11,12,1,1,1,1,1],"dep_prios":[5,5,5,5,5,5,30,30,30,30],"dependencies":["pydantic.config","__future__","typing","pydantic_core","typing_extensions","builtins","_frozen_importlib","abc","pydantic_core._pydantic_core","pydantic_core.core_schema"],"hash":"e0b1b0ba4ffea121e344096b5a8990b8f10ef857","id":"pydantic.plugin","ignore_all":true,"interface_hash":"bf74df7702cba40faf6e9d518e4778fd91a4ead3","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/plugin/__init__.py","plugin_data":null,"size":7333,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/plugin/_schema_validator.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/plugin/_schema_validator.data.json new file mode 100644 index 0000000000000000000000000000000000000000..4a144ff1021d04ac86cf9f9780da9c8c879762e5 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/plugin/_schema_validator.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic.plugin._schema_validator","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseValidateHandlerProtocol":{".class":"SymbolTableNode","cross_ref":"pydantic.plugin.BaseValidateHandlerProtocol","kind":"Gdef"},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"CoreConfig":{".class":"SymbolTableNode","cross_ref":"pydantic_core.core_schema.CoreConfig","kind":"Gdef"},"CoreSchema":{".class":"SymbolTableNode","cross_ref":"pydantic_core.core_schema.CoreSchema","kind":"Gdef"},"Event":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic.plugin._schema_validator.Event","line":18,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"on_validate_python"},{".class":"LiteralType","fallback":"builtins.str","value":"on_validate_json"},{".class":"LiteralType","fallback":"builtins.str","value":"on_validate_strings"}],"uses_pep604_syntax":false}}},"Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing.Literal","kind":"Gdef"},"P":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"ParamSpecExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.plugin._schema_validator.P","name":"P","upper_bound":"builtins.object","variance":0}},"ParamSpec":{".class":"SymbolTableNode","cross_ref":"typing_extensions.ParamSpec","kind":"Gdef"},"PluggableSchemaValidator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.plugin._schema_validator.PluggableSchemaValidator","name":"PluggableSchemaValidator","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.plugin._schema_validator.PluggableSchemaValidator","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.plugin._schema_validator","mro":["pydantic.plugin._schema_validator.PluggableSchemaValidator","builtins.object"],"names":{".class":"SymbolTable","__getattr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.plugin._schema_validator.PluggableSchemaValidator.__getattr__","name":"__getattr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["pydantic.plugin._schema_validator.PluggableSchemaValidator","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getattr__ of PluggableSchemaValidator","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0,0,0,0],"arg_names":["self","schema","schema_type","schema_type_path","schema_kind","config","plugins","plugin_settings"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.plugin._schema_validator.PluggableSchemaValidator.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,0,0],"arg_names":["self","schema","schema_type","schema_type_path","schema_kind","config","plugins","plugin_settings"],"arg_types":["pydantic.plugin._schema_validator.PluggableSchemaValidator",{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.plugin.SchemaTypePath"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.plugin.SchemaKind"},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreConfig"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"Instance","args":["pydantic.plugin.PydanticPluginProtocol"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of PluggableSchemaValidator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic.plugin._schema_validator.PluggableSchemaValidator.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_schema_validator":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.plugin._schema_validator.PluggableSchemaValidator._schema_validator","name":"_schema_validator","setter_type":null,"type":"pydantic_core._pydantic_core.SchemaValidator"}},"validate_json":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.plugin._schema_validator.PluggableSchemaValidator.validate_json","name":"validate_json","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5,5,5,5,5,5],"arg_names":["input","strict","extra","context","self_instance","allow_partial","by_alias","by_name"],"arg_types":[{".class":"UnionType","items":["builtins.str","builtins.bytes","builtins.bytearray"],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.ExtraBehavior"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"LiteralType","fallback":"builtins.str","value":"off"},{".class":"LiteralType","fallback":"builtins.str","value":"on"},{".class":"LiteralType","fallback":"builtins.str","value":"trailing-strings"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_of_any":7},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"validate_python":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.plugin._schema_validator.PluggableSchemaValidator.validate_python","name":"validate_python","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5,5,5,5,5,5,5],"arg_names":["input","strict","extra","from_attributes","context","self_instance","allow_partial","by_alias","by_name"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.ExtraBehavior"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"LiteralType","fallback":"builtins.str","value":"off"},{".class":"LiteralType","fallback":"builtins.str","value":"on"},{".class":"LiteralType","fallback":"builtins.str","value":"trailing-strings"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_of_any":7},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"validate_strings":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.plugin._schema_validator.PluggableSchemaValidator.validate_strings","name":"validate_strings","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5,5,5,5,5],"arg_names":["input","strict","extra","context","allow_partial","by_alias","by_name"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core._pydantic_core._StringInput"},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.ExtraBehavior"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"LiteralType","fallback":"builtins.str","value":"off"},{".class":"LiteralType","fallback":"builtins.str","value":"on"},{".class":"LiteralType","fallback":"builtins.str","value":"trailing-strings"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_of_any":7},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.plugin._schema_validator.PluggableSchemaValidator.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.plugin._schema_validator.PluggableSchemaValidator","values":[],"variance":0},"slots":["_schema_validator","validate_json","validate_python","validate_strings"],"tuple_type":null,"type_vars":[],"typeddict_type":null}},"PydanticPluginProtocol":{".class":"SymbolTableNode","cross_ref":"pydantic.plugin.PydanticPluginProtocol","kind":"Gdef"},"R":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.plugin._schema_validator.R","name":"R","upper_bound":"builtins.object","values":[],"variance":0}},"SchemaKind":{".class":"SymbolTableNode","cross_ref":"pydantic.plugin.SchemaKind","kind":"Gdef"},"SchemaTypePath":{".class":"SymbolTableNode","cross_ref":"pydantic.plugin.SchemaTypePath","kind":"Gdef"},"SchemaValidator":{".class":"SymbolTableNode","cross_ref":"pydantic_core._pydantic_core.SchemaValidator","kind":"Gdef"},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef"},"ValidationError":{".class":"SymbolTableNode","cross_ref":"pydantic_core._pydantic_core.ValidationError","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.plugin._schema_validator.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.plugin._schema_validator.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.plugin._schema_validator.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.plugin._schema_validator.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.plugin._schema_validator.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.plugin._schema_validator.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"build_wrapper":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["func","event_handlers"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.plugin._schema_validator.build_wrapper","name":"build_wrapper","original_first_arg":"func","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["func","event_handlers"],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"ParamSpecType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"flavor":1,"fullname":"pydantic.plugin._schema_validator.P","id":-1,"name":"P","namespace":"pydantic.plugin._schema_validator.build_wrapper","prefix":{".class":"Parameters","arg_kinds":[],"arg_names":[],"arg_types":[],"imprecise_arg_kinds":false,"variables":[]},"upper_bound":{".class":"Instance","args":["builtins.object"],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"ParamSpecType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"flavor":2,"fullname":"pydantic.plugin._schema_validator.P","id":-1,"name":"P","namespace":"pydantic.plugin._schema_validator.build_wrapper","prefix":{".class":"Parameters","arg_kinds":[],"arg_names":[],"arg_types":[],"imprecise_arg_kinds":false,"variables":[]},"upper_bound":{".class":"Instance","args":["builtins.str","builtins.object"],"extra_attrs":null,"type_ref":"builtins.dict"}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.plugin._schema_validator.R","id":-2,"name":"R","namespace":"pydantic.plugin._schema_validator.build_wrapper","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"Instance","args":["pydantic.plugin.BaseValidateHandlerProtocol"],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"build_wrapper","ret_type":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"ParamSpecType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"flavor":1,"fullname":"pydantic.plugin._schema_validator.P","id":-1,"name":"P","namespace":"pydantic.plugin._schema_validator.build_wrapper","prefix":{".class":"Parameters","arg_kinds":[],"arg_names":[],"arg_types":[],"imprecise_arg_kinds":false,"variables":[]},"upper_bound":{".class":"Instance","args":["builtins.object"],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"ParamSpecType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"flavor":2,"fullname":"pydantic.plugin._schema_validator.P","id":-1,"name":"P","namespace":"pydantic.plugin._schema_validator.build_wrapper","prefix":{".class":"Parameters","arg_kinds":[],"arg_names":[],"arg_types":[],"imprecise_arg_kinds":false,"variables":[]},"upper_bound":{".class":"Instance","args":["builtins.str","builtins.object"],"extra_attrs":null,"type_ref":"builtins.dict"}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.plugin._schema_validator.R","id":-2,"name":"R","namespace":"pydantic.plugin._schema_validator.build_wrapper","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"ParamSpecType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"flavor":0,"fullname":"pydantic.plugin._schema_validator.P","id":-1,"name":"P","namespace":"pydantic.plugin._schema_validator.build_wrapper","prefix":{".class":"Parameters","arg_kinds":[],"arg_names":[],"arg_types":[],"imprecise_arg_kinds":false,"variables":[]},"upper_bound":"builtins.object"},{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.plugin._schema_validator.R","id":-2,"name":"R","namespace":"pydantic.plugin._schema_validator.build_wrapper","upper_bound":"builtins.object","values":[],"variance":0}]}}},"create_schema_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0,1,1],"arg_names":["schema","schema_type","schema_type_module","schema_type_name","schema_kind","config","plugin_settings"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.plugin._schema_validator.create_schema_validator","name":"create_schema_validator","original_first_arg":"schema","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,1,1],"arg_names":["schema","schema_type","schema_type_module","schema_type_name","schema_kind","config","plugin_settings"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreSchema"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"builtins.str","builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.plugin.SchemaKind"},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic_core.core_schema.CoreConfig"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"create_schema_validator","ret_type":{".class":"UnionType","items":["pydantic_core._pydantic_core.SchemaValidator","pydantic.plugin._schema_validator.PluggableSchemaValidator"],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"events":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic.plugin._schema_validator.events","name":"events","setter_type":null,"type":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.plugin._schema_validator.Event"}],"extra_attrs":null,"type_ref":"builtins.list"}}},"filter_handlers":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["handler_cls","method_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.plugin._schema_validator.filter_handlers","name":"filter_handlers","original_first_arg":"handler_cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["handler_cls","method_name"],"arg_types":["pydantic.plugin.BaseValidateHandlerProtocol","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"filter_handlers","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"functools":{".class":"SymbolTableNode","cross_ref":"functools","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/plugin/_schema_validator.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/plugin/_schema_validator.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/plugin/_schema_validator.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..54042645c273cd763dea202a763a00ab741dcb3f --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/plugin/_schema_validator.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[6,13,3,5,7,9,10,1,1,1,1,1],"dep_prios":[5,25,5,10,5,5,5,5,30,30,30,30],"dependencies":["collections.abc","pydantic.plugin","__future__","functools","typing","pydantic_core","typing_extensions","builtins","_frozen_importlib","abc","pydantic_core._pydantic_core","pydantic_core.core_schema"],"hash":"e0ebdd3bbf3be10295c97b0eecfc020895d10060","id":"pydantic.plugin._schema_validator","ignore_all":true,"interface_hash":"2b8ae0988c8d1ba383b1bdfb196220359c09ebd7","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/plugin/_schema_validator.py","plugin_data":null,"size":5267,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..073f9db43de8bcdc0541c48b617901bd0691dab9 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic.v1","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","AmqpDsn":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.networks.AmqpDsn","kind":"Gdef"},"AnyHttpUrl":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.networks.AnyHttpUrl","kind":"Gdef"},"AnyStrMaxLengthError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.AnyStrMaxLengthError","kind":"Gdef","module_public":false},"AnyStrMinLengthError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.AnyStrMinLengthError","kind":"Gdef","module_public":false},"AnyUrl":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.networks.AnyUrl","kind":"Gdef"},"ArbitraryTypeError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.ArbitraryTypeError","kind":"Gdef","module_public":false},"BaseConfig":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.config.BaseConfig","kind":"Gdef"},"BaseModel":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.main.BaseModel","kind":"Gdef"},"BaseSettings":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.env_settings.BaseSettings","kind":"Gdef"},"BoolError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.BoolError","kind":"Gdef","module_public":false},"ByteSize":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.ByteSize","kind":"Gdef"},"BytesError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.BytesError","kind":"Gdef","module_public":false},"CallableError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.CallableError","kind":"Gdef","module_public":false},"ClassError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.ClassError","kind":"Gdef","module_public":false},"CockroachDsn":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.networks.CockroachDsn","kind":"Gdef"},"ColorError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.ColorError","kind":"Gdef","module_public":false},"ConfigDict":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.config.ConfigDict","kind":"Gdef"},"ConfigError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.ConfigError","kind":"Gdef","module_public":false},"ConstrainedBytes":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.ConstrainedBytes","kind":"Gdef"},"ConstrainedDate":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.ConstrainedDate","kind":"Gdef"},"ConstrainedDecimal":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.ConstrainedDecimal","kind":"Gdef"},"ConstrainedFloat":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.ConstrainedFloat","kind":"Gdef"},"ConstrainedFrozenSet":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.ConstrainedFrozenSet","kind":"Gdef"},"ConstrainedInt":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.ConstrainedInt","kind":"Gdef"},"ConstrainedList":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.ConstrainedList","kind":"Gdef"},"ConstrainedSet":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.ConstrainedSet","kind":"Gdef"},"ConstrainedStr":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.ConstrainedStr","kind":"Gdef"},"DataclassTypeError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.DataclassTypeError","kind":"Gdef","module_public":false},"DateError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.DateError","kind":"Gdef","module_public":false},"DateNotInTheFutureError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.DateNotInTheFutureError","kind":"Gdef","module_public":false},"DateNotInThePastError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.DateNotInThePastError","kind":"Gdef","module_public":false},"DateTimeError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.DateTimeError","kind":"Gdef","module_public":false},"DecimalError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.DecimalError","kind":"Gdef","module_public":false},"DecimalIsNotFiniteError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.DecimalIsNotFiniteError","kind":"Gdef","module_public":false},"DecimalMaxDigitsError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.DecimalMaxDigitsError","kind":"Gdef","module_public":false},"DecimalMaxPlacesError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.DecimalMaxPlacesError","kind":"Gdef","module_public":false},"DecimalWholeDigitsError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.DecimalWholeDigitsError","kind":"Gdef","module_public":false},"DictError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.DictError","kind":"Gdef","module_public":false},"DirectoryPath":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.DirectoryPath","kind":"Gdef"},"DurationError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.DurationError","kind":"Gdef","module_public":false},"EmailError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.EmailError","kind":"Gdef","module_public":false},"EmailStr":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.networks.EmailStr","kind":"Gdef"},"EnumError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.EnumError","kind":"Gdef","module_public":false},"EnumMemberError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.EnumMemberError","kind":"Gdef","module_public":false},"Extra":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.config.Extra","kind":"Gdef"},"ExtraError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.ExtraError","kind":"Gdef","module_public":false},"Field":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.fields.Field","kind":"Gdef"},"FilePath":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.FilePath","kind":"Gdef"},"FileUrl":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.networks.FileUrl","kind":"Gdef"},"FiniteFloat":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.FiniteFloat","kind":"Gdef"},"FloatError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.FloatError","kind":"Gdef","module_public":false},"FrozenSetError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.FrozenSetError","kind":"Gdef","module_public":false},"FrozenSetMaxLengthError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.FrozenSetMaxLengthError","kind":"Gdef","module_public":false},"FrozenSetMinLengthError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.FrozenSetMinLengthError","kind":"Gdef","module_public":false},"FutureDate":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.FutureDate","kind":"Gdef"},"HashableError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.HashableError","kind":"Gdef","module_public":false},"HttpUrl":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.networks.HttpUrl","kind":"Gdef"},"IPv4AddressError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.IPv4AddressError","kind":"Gdef","module_public":false},"IPv4InterfaceError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.IPv4InterfaceError","kind":"Gdef","module_public":false},"IPv4NetworkError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.IPv4NetworkError","kind":"Gdef","module_public":false},"IPv6AddressError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.IPv6AddressError","kind":"Gdef","module_public":false},"IPv6InterfaceError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.IPv6InterfaceError","kind":"Gdef","module_public":false},"IPv6NetworkError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.IPv6NetworkError","kind":"Gdef","module_public":false},"IPvAnyAddress":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.networks.IPvAnyAddress","kind":"Gdef"},"IPvAnyAddressError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.IPvAnyAddressError","kind":"Gdef","module_public":false},"IPvAnyInterface":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.networks.IPvAnyInterface","kind":"Gdef"},"IPvAnyInterfaceError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.IPvAnyInterfaceError","kind":"Gdef","module_public":false},"IPvAnyNetwork":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.networks.IPvAnyNetwork","kind":"Gdef"},"IPvAnyNetworkError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.IPvAnyNetworkError","kind":"Gdef","module_public":false},"IntEnumError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.IntEnumError","kind":"Gdef","module_public":false},"IntegerError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.IntegerError","kind":"Gdef","module_public":false},"InvalidByteSize":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.InvalidByteSize","kind":"Gdef","module_public":false},"InvalidByteSizeUnit":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.InvalidByteSizeUnit","kind":"Gdef","module_public":false},"InvalidDiscriminator":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.InvalidDiscriminator","kind":"Gdef","module_public":false},"InvalidLengthForBrand":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.InvalidLengthForBrand","kind":"Gdef","module_public":false},"Json":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.Json","kind":"Gdef"},"JsonError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.JsonError","kind":"Gdef","module_public":false},"JsonTypeError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.JsonTypeError","kind":"Gdef","module_public":false},"JsonWrapper":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.JsonWrapper","kind":"Gdef"},"KafkaDsn":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.networks.KafkaDsn","kind":"Gdef"},"ListError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.ListError","kind":"Gdef","module_public":false},"ListMaxLengthError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.ListMaxLengthError","kind":"Gdef","module_public":false},"ListMinLengthError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.ListMinLengthError","kind":"Gdef","module_public":false},"ListUniqueItemsError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.ListUniqueItemsError","kind":"Gdef","module_public":false},"LuhnValidationError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.LuhnValidationError","kind":"Gdef","module_public":false},"MissingDiscriminator":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.MissingDiscriminator","kind":"Gdef","module_public":false},"MissingError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.MissingError","kind":"Gdef","module_public":false},"MongoDsn":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.networks.MongoDsn","kind":"Gdef"},"NameEmail":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.networks.NameEmail","kind":"Gdef"},"NegativeFloat":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.NegativeFloat","kind":"Gdef"},"NegativeInt":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.NegativeInt","kind":"Gdef"},"NonNegativeFloat":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.NonNegativeFloat","kind":"Gdef"},"NonNegativeInt":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.NonNegativeInt","kind":"Gdef"},"NonPositiveFloat":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.NonPositiveFloat","kind":"Gdef"},"NonPositiveInt":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.NonPositiveInt","kind":"Gdef"},"NoneBytes":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.NoneBytes","kind":"Gdef"},"NoneIsAllowedError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.NoneIsAllowedError","kind":"Gdef","module_public":false},"NoneIsNotAllowedError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.NoneIsNotAllowedError","kind":"Gdef","module_public":false},"NoneStr":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.NoneStr","kind":"Gdef"},"NoneStrBytes":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.NoneStrBytes","kind":"Gdef"},"NotDigitError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.NotDigitError","kind":"Gdef","module_public":false},"NotNoneError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.NotNoneError","kind":"Gdef","module_public":false},"NumberNotGeError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.NumberNotGeError","kind":"Gdef","module_public":false},"NumberNotGtError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.NumberNotGtError","kind":"Gdef","module_public":false},"NumberNotLeError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.NumberNotLeError","kind":"Gdef","module_public":false},"NumberNotLtError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.NumberNotLtError","kind":"Gdef","module_public":false},"NumberNotMultipleError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.NumberNotMultipleError","kind":"Gdef","module_public":false},"PastDate":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.PastDate","kind":"Gdef"},"PathError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.PathError","kind":"Gdef","module_public":false},"PathNotADirectoryError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.PathNotADirectoryError","kind":"Gdef","module_public":false},"PathNotAFileError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.PathNotAFileError","kind":"Gdef","module_public":false},"PathNotExistsError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.PathNotExistsError","kind":"Gdef","module_public":false},"PatternError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.PatternError","kind":"Gdef","module_public":false},"PaymentCardNumber":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.PaymentCardNumber","kind":"Gdef"},"PositiveFloat":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.PositiveFloat","kind":"Gdef"},"PositiveInt":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.PositiveInt","kind":"Gdef"},"PostgresDsn":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.networks.PostgresDsn","kind":"Gdef"},"PrivateAttr":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.fields.PrivateAttr","kind":"Gdef"},"Protocol":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.parse.Protocol","kind":"Gdef"},"PyObject":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.PyObject","kind":"Gdef"},"PyObjectError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.PyObjectError","kind":"Gdef","module_public":false},"PydanticTypeError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.PydanticTypeError","kind":"Gdef","module_public":false},"PydanticValueError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.PydanticValueError","kind":"Gdef","module_public":false},"RedisDsn":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.networks.RedisDsn","kind":"Gdef"},"Required":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.fields.Required","kind":"Gdef"},"SecretBytes":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.SecretBytes","kind":"Gdef"},"SecretField":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.SecretField","kind":"Gdef"},"SecretStr":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.SecretStr","kind":"Gdef"},"SequenceError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.SequenceError","kind":"Gdef","module_public":false},"SetError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.SetError","kind":"Gdef","module_public":false},"SetMaxLengthError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.SetMaxLengthError","kind":"Gdef","module_public":false},"SetMinLengthError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.SetMinLengthError","kind":"Gdef","module_public":false},"StrBytes":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.StrBytes","kind":"Gdef"},"StrError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.StrError","kind":"Gdef","module_public":false},"StrRegexError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.StrRegexError","kind":"Gdef","module_public":false},"StrictBool":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.StrictBool","kind":"Gdef"},"StrictBoolError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.StrictBoolError","kind":"Gdef","module_public":false},"StrictBytes":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.StrictBytes","kind":"Gdef"},"StrictFloat":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.StrictFloat","kind":"Gdef"},"StrictInt":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.StrictInt","kind":"Gdef"},"StrictStr":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.StrictStr","kind":"Gdef"},"SubclassError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.SubclassError","kind":"Gdef","module_public":false},"TimeError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.TimeError","kind":"Gdef","module_public":false},"TupleError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.TupleError","kind":"Gdef","module_public":false},"TupleLengthError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.TupleLengthError","kind":"Gdef","module_public":false},"UUID1":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.UUID1","kind":"Gdef"},"UUID3":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.UUID3","kind":"Gdef"},"UUID4":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.UUID4","kind":"Gdef"},"UUID5":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.UUID5","kind":"Gdef"},"UUIDError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.UUIDError","kind":"Gdef","module_public":false},"UUIDVersionError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.UUIDVersionError","kind":"Gdef","module_public":false},"UrlError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.UrlError","kind":"Gdef","module_public":false},"UrlExtraError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.UrlExtraError","kind":"Gdef","module_public":false},"UrlHostError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.UrlHostError","kind":"Gdef","module_public":false},"UrlHostTldError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.UrlHostTldError","kind":"Gdef","module_public":false},"UrlPortError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.UrlPortError","kind":"Gdef","module_public":false},"UrlSchemeError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.UrlSchemeError","kind":"Gdef","module_public":false},"UrlSchemePermittedError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.UrlSchemePermittedError","kind":"Gdef","module_public":false},"UrlUserInfoError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.UrlUserInfoError","kind":"Gdef","module_public":false},"VERSION":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.version.VERSION","kind":"Gdef"},"ValidationError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.error_wrappers.ValidationError","kind":"Gdef"},"WrongConstantError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.WrongConstantError","kind":"Gdef","module_public":false},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"__version__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.__version__","name":"__version__","setter_type":null,"type":"builtins.str"}},"compiled":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.version.compiled","kind":"Gdef"},"conbytes":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.conbytes","kind":"Gdef"},"condate":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.condate","kind":"Gdef"},"condecimal":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.condecimal","kind":"Gdef"},"confloat":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.confloat","kind":"Gdef"},"confrozenset":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.confrozenset","kind":"Gdef"},"conint":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.conint","kind":"Gdef"},"conlist":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.conlist","kind":"Gdef"},"conset":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.conset","kind":"Gdef"},"constr":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.constr","kind":"Gdef"},"create_model":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.main.create_model","kind":"Gdef"},"create_model_from_namedtuple":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.annotated_types.create_model_from_namedtuple","kind":"Gdef"},"create_model_from_typeddict":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.annotated_types.create_model_from_typeddict","kind":"Gdef"},"dataclasses":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.dataclasses","kind":"Gdef"},"parse_file_as":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.tools.parse_file_as","kind":"Gdef"},"parse_obj_as":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.tools.parse_obj_as","kind":"Gdef"},"parse_raw_as":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.tools.parse_raw_as","kind":"Gdef"},"root_validator":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.class_validators.root_validator","kind":"Gdef"},"schema_json_of":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.tools.schema_json_of","kind":"Gdef"},"schema_of":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.tools.schema_of","kind":"Gdef"},"stricturl":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.networks.stricturl","kind":"Gdef"},"sys":{".class":"SymbolTableNode","cross_ref":"sys","kind":"Gdef","module_public":false},"validate_arguments":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.decorator.validate_arguments","kind":"Gdef"},"validate_email":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.networks.validate_email","kind":"Gdef"},"validate_model":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.main.validate_model","kind":"Gdef"},"validator":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.class_validators.validator","kind":"Gdef"},"warnings":{".class":"SymbolTableNode","cross_ref":"warnings","kind":"Gdef","module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/__init__.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..405e2f0f6631bea8dbf85f1d02d0e2a4b4ddc240 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,2,3,1,1,1,1,1],"dep_prios":[10,5,5,5,5,5,5,5,5,5,5,5,5,5,5,10,10,5,30,30,30,30],"dependencies":["pydantic.v1.dataclasses","pydantic.v1.annotated_types","pydantic.v1.class_validators","pydantic.v1.config","pydantic.v1.decorator","pydantic.v1.env_settings","pydantic.v1.error_wrappers","pydantic.v1.errors","pydantic.v1.fields","pydantic.v1.main","pydantic.v1.networks","pydantic.v1.parse","pydantic.v1.tools","pydantic.v1.types","pydantic.v1.version","sys","warnings","builtins","_frozen_importlib","_typeshed","abc","typing"],"hash":"e5e1c8d51774ce08d949515528d85217d7af4de1","id":"pydantic.v1","ignore_all":true,"interface_hash":"42c5bcc23a80eaeb7af63a86d6ca03579dc899f2","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/__init__.py","plugin_data":null,"size":3164,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/annotated_types.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/annotated_types.data.json new file mode 100644 index 0000000000000000000000000000000000000000..8d86bfdd69b74afd5a2732421f8a5b5b6a882a63 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/annotated_types.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic.v1.annotated_types","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseModel":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.main.BaseModel","kind":"Gdef"},"Dict":{".class":"SymbolTableNode","cross_ref":"typing.Dict","kind":"Gdef"},"FrozenSet":{".class":"SymbolTableNode","cross_ref":"typing.FrozenSet","kind":"Gdef"},"NamedTuple":{".class":"SymbolTableNode","cross_ref":"typing.NamedTuple","kind":"Gdef"},"Required":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.fields.Required","kind":"Gdef"},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"Type":{".class":"SymbolTableNode","cross_ref":"typing.Type","kind":"Gdef"},"TypedDict":{".class":"SymbolTableNode","cross_ref":"typing.TypedDict","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.annotated_types.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.annotated_types.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.annotated_types.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.annotated_types.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.annotated_types.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.annotated_types.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"create_model":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.main.create_model","kind":"Gdef"},"create_model_from_namedtuple":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,4],"arg_names":["namedtuple_cls","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.annotated_types.create_model_from_namedtuple","name":"create_model_from_namedtuple","original_first_arg":"namedtuple_cls","type":{".class":"CallableType","arg_kinds":[0,4],"arg_names":["namedtuple_cls","kwargs"],"arg_types":[{".class":"TypeType","item":"typing.NamedTuple"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"create_model_from_namedtuple","ret_type":{".class":"TypeType","item":"pydantic.v1.main.BaseModel"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"create_model_from_typeddict":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,4],"arg_names":["typeddict_cls","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.annotated_types.create_model_from_typeddict","name":"create_model_from_typeddict","original_first_arg":"typeddict_cls","type":{".class":"CallableType","arg_kinds":[0,4],"arg_names":["typeddict_cls","kwargs"],"arg_types":[{".class":"TypeType","item":{".class":"UnboundType","args":[],"expr":"TypedDict","expr_fallback":"builtins.str","name":"TypedDict"}},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"create_model_from_typeddict","ret_type":{".class":"TypeType","item":"pydantic.v1.main.BaseModel"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_legacy_typeddict":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["typeddict_cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.annotated_types.is_legacy_typeddict","name":"is_legacy_typeddict","original_first_arg":"typeddict_cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["typeddict_cls"],"arg_types":[{".class":"TypeType","item":{".class":"UnboundType","args":[],"expr":"TypedDict","expr_fallback":"builtins.str","name":"TypedDict"}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_legacy_typeddict","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_typeddict":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.is_typeddict","kind":"Gdef"},"is_typeddict_special":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.is_typeddict_special","kind":"Gdef"},"sys":{".class":"SymbolTableNode","cross_ref":"sys","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/annotated_types.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/annotated_types.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/annotated_types.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..2a8a53cdbb29da9fb9951d25c9c85963b6f4c469 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/annotated_types.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[4,5,6,1,2,9,1,1,1,1,1],"dep_prios":[5,5,5,10,5,25,5,30,30,30,30],"dependencies":["pydantic.v1.fields","pydantic.v1.main","pydantic.v1.typing","sys","typing","typing_extensions","builtins","_frozen_importlib","_typeshed","abc","pydantic.v1.utils"],"hash":"a5f5b55199dd505402a18afeb3ceb79db1f107d1","id":"pydantic.v1.annotated_types","ignore_all":true,"interface_hash":"3e067ba8d4ddb72dd0ed09d1ae5d9b2a72ae1c29","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/annotated_types.py","plugin_data":null,"size":3157,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/class_validators.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/class_validators.data.json new file mode 100644 index 0000000000000000000000000000000000000000..ff18a583fe3057ef047a9b533119cffa23ac034e --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/class_validators.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic.v1.class_validators","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"AnyCallable":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.AnyCallable","kind":"Gdef"},"AnyClassMethod":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.AnyClassMethod","kind":"Gdef"},"BaseConfig":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.config.BaseConfig","kind":"Gdef"},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"ChainMap":{".class":"SymbolTableNode","cross_ref":"collections.ChainMap","kind":"Gdef"},"ConfigError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.ConfigError","kind":"Gdef"},"Dict":{".class":"SymbolTableNode","cross_ref":"typing.Dict","kind":"Gdef"},"FunctionType":{".class":"SymbolTableNode","cross_ref":"types.FunctionType","kind":"Gdef"},"Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef"},"List":{".class":"SymbolTableNode","cross_ref":"typing.List","kind":"Gdef"},"ModelField":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.fields.ModelField","kind":"Gdef"},"ModelOrDc":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.ModelOrDc","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"ROOT_KEY":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.ROOT_KEY","kind":"Gdef"},"ROOT_VALIDATOR_CONFIG_KEY":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.class_validators.ROOT_VALIDATOR_CONFIG_KEY","name":"ROOT_VALIDATOR_CONFIG_KEY","setter_type":null,"type":"builtins.str"}},"Set":{".class":"SymbolTableNode","cross_ref":"typing.Set","kind":"Gdef"},"Signature":{".class":"SymbolTableNode","cross_ref":"inspect.Signature","kind":"Gdef"},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"Tuple":{".class":"SymbolTableNode","cross_ref":"typing.Tuple","kind":"Gdef"},"Type":{".class":"SymbolTableNode","cross_ref":"typing.Type","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"VALIDATOR_CONFIG_KEY":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.class_validators.VALIDATOR_CONFIG_KEY","name":"VALIDATOR_CONFIG_KEY","setter_type":null,"type":"builtins.str"}},"Validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.class_validators.Validator","name":"Validator","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.class_validators.Validator","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.class_validators","mro":["pydantic.v1.class_validators.Validator","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1,1],"arg_names":["self","func","pre","each_item","always","check_fields","skip_on_failure"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.class_validators.Validator.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1,1],"arg_names":["self","func","pre","each_item","always","check_fields","skip_on_failure"],"arg_types":["pydantic.v1.class_validators.Validator",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyCallable"},"builtins.bool","builtins.bool","builtins.bool","builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of Validator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic.v1.class_validators.Validator.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"always":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.class_validators.Validator.always","name":"always","setter_type":null,"type":"builtins.bool"}},"check_fields":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.class_validators.Validator.check_fields","name":"check_fields","setter_type":null,"type":"builtins.bool"}},"each_item":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.class_validators.Validator.each_item","name":"each_item","setter_type":null,"type":"builtins.bool"}},"func":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.class_validators.Validator.func","name":"func","setter_type":null,"type":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"pre":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.class_validators.Validator.pre","name":"pre","setter_type":null,"type":"builtins.bool"}},"skip_on_failure":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.class_validators.Validator.skip_on_failure","name":"skip_on_failure","setter_type":null,"type":"builtins.bool"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.class_validators.Validator.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.class_validators.Validator","values":[],"variance":0},"slots":["always","check_fields","each_item","func","pre","skip_on_failure"],"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ValidatorCallable":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.class_validators.ValidatorCallable","line":43,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":[null,null,null,null,null],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.ModelOrDc"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"},"pydantic.v1.fields.ModelField",{".class":"TypeType","item":"pydantic.v1.config.BaseConfig"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"ValidatorGroup":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.class_validators.ValidatorGroup","name":"ValidatorGroup","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.class_validators.ValidatorGroup","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.class_validators","mro":["pydantic.v1.class_validators.ValidatorGroup","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","validators"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.class_validators.ValidatorGroup.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","validators"],"arg_types":["pydantic.v1.class_validators.ValidatorGroup",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.class_validators.ValidatorListDict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of ValidatorGroup","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"check_for_unused":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.class_validators.ValidatorGroup.check_for_unused","name":"check_for_unused","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.class_validators.ValidatorGroup"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"check_for_unused of ValidatorGroup","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_validators":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","name"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.class_validators.ValidatorGroup.get_validators","name":"get_validators","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","name"],"arg_types":["pydantic.v1.class_validators.ValidatorGroup","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_validators of ValidatorGroup","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","pydantic.v1.class_validators.Validator"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"used_validators":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.class_validators.ValidatorGroup.used_validators","name":"used_validators","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"validators":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.class_validators.ValidatorGroup.validators","name":"validators","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.class_validators.ValidatorListDict"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.class_validators.ValidatorGroup.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.class_validators.ValidatorGroup","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ValidatorListDict":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.class_validators.ValidatorListDict","line":45,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic.v1.class_validators.Validator"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"ValidatorsList":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.class_validators.ValidatorsList","line":44,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.class_validators.ValidatorCallable"}],"extra_attrs":null,"type_ref":"builtins.list"}}},"_FUNCS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic.v1.class_validators._FUNCS","name":"_FUNCS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.class_validators.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.class_validators.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.class_validators.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.class_validators.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.class_validators.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.class_validators.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_generic_validator_basic":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["validator","sig","args"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.class_validators._generic_validator_basic","name":"_generic_validator_basic","original_first_arg":"validator","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["validator","sig","args"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyCallable"},"inspect.Signature",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_generic_validator_basic","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.class_validators.ValidatorCallable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_generic_validator_cls":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["validator","sig","args"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.class_validators._generic_validator_cls","name":"_generic_validator_cls","original_first_arg":"validator","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["validator","sig","args"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyCallable"},"inspect.Signature",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_generic_validator_cls","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.class_validators.ValidatorCallable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_prepare_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["function","allow_reuse"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.class_validators._prepare_validator","name":"_prepare_validator","original_first_arg":"function","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["function","allow_reuse"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyCallable"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_prepare_validator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyClassMethod"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"all_kwargs":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.class_validators.all_kwargs","name":"all_kwargs","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"chain":{".class":"SymbolTableNode","cross_ref":"itertools.chain","kind":"Gdef"},"extract_root_validators":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["namespace"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.class_validators.extract_root_validators","name":"extract_root_validators","original_first_arg":"namespace","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["namespace"],"arg_types":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"extract_root_validators","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyCallable"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyCallable"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"builtins.list"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"extract_validators":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["namespace"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.class_validators.extract_validators","name":"extract_validators","original_first_arg":"namespace","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["namespace"],"arg_types":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"extract_validators","ret_type":{".class":"Instance","args":["builtins.str",{".class":"Instance","args":["pydantic.v1.class_validators.Validator"],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"gather_all_validators":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["type_"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.class_validators.gather_all_validators","name":"gather_all_validators","original_first_arg":"type_","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["type_"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.ModelOrDc"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"gather_all_validators","ret_type":{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyClassMethod"}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"in_ipython":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.in_ipython","kind":"Gdef"},"inherit_validators":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["base_validators","validators"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.class_validators.inherit_validators","name":"inherit_validators","original_first_arg":"base_validators","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["base_validators","validators"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.class_validators.ValidatorListDict"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.class_validators.ValidatorListDict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"inherit_validators","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.class_validators.ValidatorListDict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"make_generic_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["validator"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.class_validators.make_generic_validator","name":"make_generic_validator","original_first_arg":"validator","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["validator"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyCallable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"make_generic_validator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.class_validators.ValidatorCallable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef"},"partial":{".class":"SymbolTableNode","cross_ref":"functools.partial","kind":"Gdef"},"partialmethod":{".class":"SymbolTableNode","cross_ref":"functools.partialmethod","kind":"Gdef"},"prep_validators":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v_funcs"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.class_validators.prep_validators","name":"prep_validators","original_first_arg":"v_funcs","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v_funcs"],"arg_types":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyCallable"}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prep_validators","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.class_validators.ValidatorsList"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"root_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"pydantic.v1.class_validators.root_validator","impl":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1,5,5,5],"arg_names":["_func","pre","allow_reuse","skip_on_failure"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload"],"fullname":"pydantic.v1.class_validators.root_validator","name":"root_validator","original_first_arg":"_func","type":{".class":"CallableType","arg_kinds":[1,5,5,5],"arg_names":["_func","pre","allow_reuse","skip_on_failure"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyCallable"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool","builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"root_validator","ret_type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyClassMethod"},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyCallable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyClassMethod"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["_func"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"pydantic.v1.class_validators.root_validator","name":"root_validator","original_first_arg":"_func","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["_func"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyCallable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"root_validator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyClassMethod"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.class_validators.root_validator","name":"root_validator","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["_func"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyCallable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"root_validator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyClassMethod"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5],"arg_names":["pre","allow_reuse","skip_on_failure"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"pydantic.v1.class_validators.root_validator","name":"root_validator","original_first_arg":"pre","type":{".class":"CallableType","arg_kinds":[5,5,5],"arg_names":["pre","allow_reuse","skip_on_failure"],"arg_types":["builtins.bool","builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"root_validator","ret_type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyCallable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyClassMethod"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.class_validators.root_validator","name":"root_validator","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5],"arg_names":["pre","allow_reuse","skip_on_failure"],"arg_types":["builtins.bool","builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"root_validator","ret_type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyCallable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyClassMethod"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["_func"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyCallable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"root_validator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyClassMethod"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[5,5,5],"arg_names":["pre","allow_reuse","skip_on_failure"],"arg_types":["builtins.bool","builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"root_validator","ret_type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyCallable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyClassMethod"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[2,5,5,5,5,5,5],"arg_names":["fields","pre","each_item","always","check_fields","whole","allow_reuse"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.class_validators.validator","name":"validator","original_first_arg":"fields","type":{".class":"CallableType","arg_kinds":[2,5,5,5,5,5,5],"arg_names":["fields","pre","each_item","always","check_fields","whole","allow_reuse"],"arg_types":["builtins.str","builtins.bool","builtins.bool","builtins.bool","builtins.bool",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validator","ret_type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyCallable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyClassMethod"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"warnings":{".class":"SymbolTableNode","cross_ref":"warnings","kind":"Gdef"},"wraps":{".class":"SymbolTableNode","cross_ref":"functools.wraps","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/class_validators.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/class_validators.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/class_validators.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..a1062de2fae08b185bb8ba7fd50f7be04c0d370b --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/class_validators.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[8,9,10,39,40,41,1,2,3,4,5,6,37,1,1,1,1,1,1],"dep_prios":[5,5,5,25,25,25,10,5,5,5,5,5,25,5,30,30,30,30,30],"dependencies":["pydantic.v1.errors","pydantic.v1.typing","pydantic.v1.utils","pydantic.v1.config","pydantic.v1.fields","pydantic.v1.types","warnings","collections","functools","itertools","types","typing","inspect","builtins","_frozen_importlib","_typeshed","abc","pydantic.v1.dataclasses","pydantic.v1.main"],"hash":"765200ce3fa45f55d2d316d7816c54f43dc4dc02","id":"pydantic.v1.class_validators","ignore_all":true,"interface_hash":"702fce293fe456e85727aa3798e99452e12a8d1a","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/class_validators.py","plugin_data":null,"size":14672,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/color.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/color.data.json new file mode 100644 index 0000000000000000000000000000000000000000..9f08953244630104ad32a5ab6f03e654853591db --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/color.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic.v1.color","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"COLORS_BY_NAME":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.color.COLORS_BY_NAME","name":"COLORS_BY_NAME","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"COLORS_BY_VALUE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.color.COLORS_BY_VALUE","name":"COLORS_BY_VALUE","setter_type":null,"type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.tuple"}},"builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"CallableGenerator":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.CallableGenerator","kind":"Gdef"},"Color":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.utils.Representation"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.color.Color","name":"Color","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.color.Color","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.color","mro":["pydantic.v1.color.Color","pydantic.v1.utils.Representation","builtins.object"],"names":{".class":"SymbolTable","__eq__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.color.Color.__eq__","name":"__eq__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["pydantic.v1.color.Color",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__eq__ of Color","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__get_validators__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.color.Color.__get_validators__","name":"__get_validators__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.color.Color"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of Color","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.color.Color.__get_validators__","name":"__get_validators__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.color.Color"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of Color","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__hash__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.color.Color.__hash__","name":"__hash__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.color.Color"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__hash__ of Color","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.color.Color.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","value"],"arg_types":["pydantic.v1.color.Color",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.color.ColorType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of Color","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__modify_schema__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","field_schema"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.color.Color.__modify_schema__","name":"__modify_schema__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field_schema"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.color.Color"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__modify_schema__ of Color","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.color.Color.__modify_schema__","name":"__modify_schema__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field_schema"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.color.Color"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__modify_schema__ of Color","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__repr_args__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.color.Color.__repr_args__","name":"__repr_args__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.color.Color"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr_args__ of Color","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.ReprArgs"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic.v1.color.Color.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"__str__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.color.Color.__str__","name":"__str__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["pydantic.v1.color.Color"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__str__ of Color","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_alpha_float":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.color.Color._alpha_float","name":"_alpha_float","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.color.Color"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_alpha_float of Color","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_original":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic.v1.color.Color._original","name":"_original","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.color.ColorType"}}},"_rgba":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic.v1.color.Color._rgba","name":"_rgba","setter_type":null,"type":"pydantic.v1.color.RGBA"}},"as_hex":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.color.Color.as_hex","name":"as_hex","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.color.Color"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_hex of Color","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"as_hsl":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.color.Color.as_hsl","name":"as_hsl","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.color.Color"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_hsl of Color","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"as_hsl_tuple":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5],"arg_names":["self","alpha"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.color.Color.as_hsl_tuple","name":"as_hsl_tuple","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5],"arg_names":["self","alpha"],"arg_types":["pydantic.v1.color.Color",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_hsl_tuple of Color","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.color.HslColorTuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"as_named":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5],"arg_names":["self","fallback"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.color.Color.as_named","name":"as_named","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5],"arg_names":["self","fallback"],"arg_types":["pydantic.v1.color.Color","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_named of Color","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"as_rgb":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.color.Color.as_rgb","name":"as_rgb","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.color.Color"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_rgb of Color","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"as_rgb_tuple":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5],"arg_names":["self","alpha"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.color.Color.as_rgb_tuple","name":"as_rgb_tuple","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5],"arg_names":["self","alpha"],"arg_types":["pydantic.v1.color.Color",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"as_rgb_tuple of Color","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.color.ColorTuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"original":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.color.Color.original","name":"original","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.color.Color"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"original of Color","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.color.ColorType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.color.Color.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.color.Color","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ColorError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.ColorError","kind":"Gdef"},"ColorTuple":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic.v1.color.ColorTuple","line":21,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.float"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":false}}},"ColorType":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic.v1.color.ColorType","line":22,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.color.ColorTuple"},"builtins.str"],"uses_pep604_syntax":false}}},"Dict":{".class":"SymbolTableNode","cross_ref":"typing.Dict","kind":"Gdef"},"HslColorTuple":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic.v1.color.HslColorTuple","line":23,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"TupleType","implicit":false,"items":["builtins.float","builtins.float","builtins.float"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.float","builtins.float","builtins.float","builtins.float"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":false}}},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"RGBA":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.color.RGBA","name":"RGBA","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.color.RGBA","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.color","mro":["pydantic.v1.color.RGBA","builtins.object"],"names":{".class":"SymbolTable","__getitem__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.color.RGBA.__getitem__","name":"__getitem__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["pydantic.v1.color.RGBA",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of RGBA","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0],"arg_names":["self","r","g","b","alpha"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.color.RGBA.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":["self","r","g","b","alpha"],"arg_types":["pydantic.v1.color.RGBA","builtins.float","builtins.float","builtins.float",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of RGBA","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic.v1.color.RGBA.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_tuple":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic.v1.color.RGBA._tuple","name":"_tuple","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.float","builtins.float","builtins.float",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"alpha":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.color.RGBA.alpha","name":"alpha","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"b":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.color.RGBA.b","name":"b","setter_type":null,"type":"builtins.float"}},"g":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.color.RGBA.g","name":"g","setter_type":null,"type":"builtins.float"}},"r":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.color.RGBA.r","name":"r","setter_type":null,"type":"builtins.float"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.color.RGBA.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.color.RGBA","values":[],"variance":0},"slots":["_tuple","alpha","b","g","r"],"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ReprArgs":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.ReprArgs","kind":"Gdef"},"Representation":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.Representation","kind":"Gdef"},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"Tuple":{".class":"SymbolTableNode","cross_ref":"typing.Tuple","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.color.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.color.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.color.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.color.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.color.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.color.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_r_255":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.color._r_255","name":"_r_255","setter_type":null,"type":"builtins.str"}},"_r_alpha":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.color._r_alpha","name":"_r_alpha","setter_type":null,"type":"builtins.str"}},"_r_comma":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.color._r_comma","name":"_r_comma","setter_type":null,"type":"builtins.str"}},"_r_h":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.color._r_h","name":"_r_h","setter_type":null,"type":"builtins.str"}},"_r_sl":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.color._r_sl","name":"_r_sl","setter_type":null,"type":"builtins.str"}},"almost_equal_floats":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.almost_equal_floats","kind":"Gdef"},"cast":{".class":"SymbolTableNode","cross_ref":"typing.cast","kind":"Gdef"},"float_to_255":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["c"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.color.float_to_255","name":"float_to_255","original_first_arg":"c","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["c"],"arg_types":["builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"float_to_255","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"hls_to_rgb":{".class":"SymbolTableNode","cross_ref":"colorsys.hls_to_rgb","kind":"Gdef"},"ints_to_rgba":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["r","g","b","alpha"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.color.ints_to_rgba","name":"ints_to_rgba","original_first_arg":"r","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["r","g","b","alpha"],"arg_types":[{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ints_to_rgba","ret_type":"pydantic.v1.color.RGBA","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"math":{".class":"SymbolTableNode","cross_ref":"math","kind":"Gdef"},"parse_color_value":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["value","max_val"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.color.parse_color_value","name":"parse_color_value","original_first_arg":"value","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["value","max_val"],"arg_types":[{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":false},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parse_color_value","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"parse_float_alpha":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["value"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.color.parse_float_alpha","name":"parse_float_alpha","original_first_arg":"value","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["value"],"arg_types":[{".class":"UnionType","items":[{".class":"NoneType"},"builtins.str","builtins.float","builtins.int"],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parse_float_alpha","ret_type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"parse_hsl":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1],"arg_names":["h","h_units","sat","light","alpha"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.color.parse_hsl","name":"parse_hsl","original_first_arg":"h","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["h","h_units","sat","light","alpha"],"arg_types":["builtins.str","builtins.str","builtins.str","builtins.str",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parse_hsl","ret_type":"pydantic.v1.color.RGBA","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"parse_str":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["value"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.color.parse_str","name":"parse_str","original_first_arg":"value","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["value"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parse_str","ret_type":"pydantic.v1.color.RGBA","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"parse_tuple":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["value"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.color.parse_tuple","name":"parse_tuple","original_first_arg":"value","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["value"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parse_tuple","ret_type":"pydantic.v1.color.RGBA","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"r_hex_long":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.color.r_hex_long","name":"r_hex_long","setter_type":null,"type":"builtins.str"}},"r_hex_short":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.color.r_hex_short","name":"r_hex_short","setter_type":null,"type":"builtins.str"}},"r_hsl":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.color.r_hsl","name":"r_hsl","setter_type":null,"type":"builtins.str"}},"r_hsla":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.color.r_hsla","name":"r_hsla","setter_type":null,"type":"builtins.str"}},"r_rgb":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.color.r_rgb","name":"r_rgb","setter_type":null,"type":"builtins.str"}},"r_rgba":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.color.r_rgba","name":"r_rgba","setter_type":null,"type":"builtins.str"}},"rads":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.color.rads","name":"rads","setter_type":null,"type":"builtins.float"}},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef"},"repeat_colors":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.color.repeat_colors","name":"repeat_colors","setter_type":null,"type":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.set"}}},"rgb_to_hls":{".class":"SymbolTableNode","cross_ref":"colorsys.rgb_to_hls","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/color.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/color.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/color.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..50634faa0651f8f1bed81ecef6f55fe2ef6d2fb2 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/color.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[15,16,19,10,11,12,13,1,1,1,1,1,1],"dep_prios":[5,5,25,10,10,5,5,5,30,30,30,30,30],"dependencies":["pydantic.v1.errors","pydantic.v1.utils","pydantic.v1.typing","math","re","colorsys","typing","builtins","_collections_abc","_frozen_importlib","_typeshed","abc","typing_extensions"],"hash":"52578d2c32f7ab7000b737d709bfeb70e7be50fc","id":"pydantic.v1.color","ignore_all":true,"interface_hash":"d62c7616388e0f2a528b05681351238fe343b0bc","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/color.py","plugin_data":null,"size":16844,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/config.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/config.data.json new file mode 100644 index 0000000000000000000000000000000000000000..24ea47d8b29c3ed3de816a35c392f06c37161097 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/config.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic.v1.config","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_public":false},"AnyArgTCallable":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.AnyArgTCallable","kind":"Gdef","module_public":false},"AnyCallable":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.AnyCallable","kind":"Gdef","module_public":false},"BaseConfig":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.config.BaseConfig","name":"BaseConfig","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.config.BaseConfig","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.config","mro":["pydantic.v1.config.BaseConfig","builtins.object"],"names":{".class":"SymbolTable","alias_generator":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.config.BaseConfig.alias_generator","name":"alias_generator","setter_type":null,"type":{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"allow_inf_nan":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.config.BaseConfig.allow_inf_nan","name":"allow_inf_nan","setter_type":null,"type":"builtins.bool"}},"allow_mutation":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.config.BaseConfig.allow_mutation","name":"allow_mutation","setter_type":null,"type":"builtins.bool"}},"allow_population_by_field_name":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.config.BaseConfig.allow_population_by_field_name","name":"allow_population_by_field_name","setter_type":null,"type":"builtins.bool"}},"anystr_lower":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.config.BaseConfig.anystr_lower","name":"anystr_lower","setter_type":null,"type":"builtins.bool"}},"anystr_strip_whitespace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.config.BaseConfig.anystr_strip_whitespace","name":"anystr_strip_whitespace","setter_type":null,"type":"builtins.bool"}},"anystr_upper":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.config.BaseConfig.anystr_upper","name":"anystr_upper","setter_type":null,"type":"builtins.bool"}},"arbitrary_types_allowed":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.config.BaseConfig.arbitrary_types_allowed","name":"arbitrary_types_allowed","setter_type":null,"type":"builtins.bool"}},"copy_on_model_validation":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.config.BaseConfig.copy_on_model_validation","name":"copy_on_model_validation","setter_type":null,"type":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"none"},{".class":"LiteralType","fallback":"builtins.str","value":"deep"},{".class":"LiteralType","fallback":"builtins.str","value":"shallow"}],"uses_pep604_syntax":false}}},"error_msg_templates":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.config.BaseConfig.error_msg_templates","name":"error_msg_templates","setter_type":null,"type":{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"extra":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.config.BaseConfig.extra","name":"extra","setter_type":null,"type":"pydantic.v1.config.Extra"}},"fields":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.config.BaseConfig.fields","name":"fields","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"frozen":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.config.BaseConfig.frozen","name":"frozen","setter_type":null,"type":"builtins.bool"}},"get_field_info":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","name"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.config.BaseConfig.get_field_info","name":"get_field_info","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","name"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.config.BaseConfig"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_field_info of BaseConfig","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.config.BaseConfig.get_field_info","name":"get_field_info","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","name"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.config.BaseConfig"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_field_info of BaseConfig","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"getter_dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.config.BaseConfig.getter_dict","name":"getter_dict","setter_type":null,"type":{".class":"TypeType","item":"pydantic.v1.utils.GetterDict"}}},"json_dumps":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.config.BaseConfig.json_dumps","name":"json_dumps","setter_type":null,"type":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"json_encoders":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.config.BaseConfig.json_encoders","name":"json_encoders","setter_type":null,"type":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},"builtins.str","typing.ForwardRef"],"uses_pep604_syntax":false},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyCallable"}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"json_loads":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.config.BaseConfig.json_loads","name":"json_loads","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"keep_untouched":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.config.BaseConfig.keep_untouched","name":"keep_untouched","setter_type":null,"type":{".class":"Instance","args":["builtins.type"],"extra_attrs":null,"type_ref":"builtins.tuple"}}},"max_anystr_length":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.config.BaseConfig.max_anystr_length","name":"max_anystr_length","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"min_anystr_length":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.config.BaseConfig.min_anystr_length","name":"min_anystr_length","setter_type":null,"type":"builtins.int"}},"orm_mode":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.config.BaseConfig.orm_mode","name":"orm_mode","setter_type":null,"type":"builtins.bool"}},"post_init_call":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.config.BaseConfig.post_init_call","name":"post_init_call","setter_type":null,"type":{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"before_validation"},{".class":"LiteralType","fallback":"builtins.str","value":"after_validation"}],"uses_pep604_syntax":false}}},"prepare_field":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","field"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.config.BaseConfig.prepare_field","name":"prepare_field","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.config.BaseConfig"},"pydantic.v1.fields.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prepare_field of BaseConfig","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.config.BaseConfig.prepare_field","name":"prepare_field","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.config.BaseConfig"},"pydantic.v1.fields.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prepare_field of BaseConfig","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"schema_extra":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.config.BaseConfig.schema_extra","name":"schema_extra","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"pydantic.v1.config.SchemaExtraCallable"],"uses_pep604_syntax":false}}},"smart_union":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.config.BaseConfig.smart_union","name":"smart_union","setter_type":null,"type":"builtins.bool"}},"title":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.config.BaseConfig.title","name":"title","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"underscore_attrs_are_private":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.config.BaseConfig.underscore_attrs_are_private","name":"underscore_attrs_are_private","setter_type":null,"type":"builtins.bool"}},"use_enum_values":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.config.BaseConfig.use_enum_values","name":"use_enum_values","setter_type":null,"type":"builtins.bool"}},"validate_all":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.config.BaseConfig.validate_all","name":"validate_all","setter_type":null,"type":"builtins.bool"}},"validate_assignment":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.config.BaseConfig.validate_assignment","name":"validate_assignment","setter_type":null,"type":"builtins.bool"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.config.BaseConfig.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.config.BaseConfig","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"BaseModel":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.main.BaseModel","kind":"Gdef","module_public":false},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef","module_public":false},"ConfigDict":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.config.ConfigDict","name":"ConfigDict","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.config.ConfigDict","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.config","mro":["pydantic.v1.config.ConfigDict","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["title",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],["anystr_lower","builtins.bool"],["anystr_strip_whitespace","builtins.bool"],["min_anystr_length","builtins.int"],["max_anystr_length",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],["validate_all","builtins.bool"],["extra","pydantic.v1.config.Extra"],["allow_mutation","builtins.bool"],["frozen","builtins.bool"],["allow_population_by_field_name","builtins.bool"],["use_enum_values","builtins.bool"],["fields",{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"}],["validate_assignment","builtins.bool"],["error_msg_templates",{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}],["arbitrary_types_allowed","builtins.bool"],["orm_mode","builtins.bool"],["getter_dict",{".class":"TypeType","item":"pydantic.v1.utils.GetterDict"}],["alias_generator",{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":false}],["keep_untouched",{".class":"Instance","args":["builtins.type"],"extra_attrs":null,"type_ref":"builtins.tuple"}],["schema_extra",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","builtins.object"],"extra_attrs":null,"type_ref":"builtins.dict"},"pydantic.v1.config.SchemaExtraCallable"],"uses_pep604_syntax":false}],["json_loads",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.object","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],["json_dumps",{".class":"TypeAliasType","args":["builtins.str"],"type_ref":"pydantic.v1.typing.AnyArgTCallable"}],["json_encoders",{".class":"Instance","args":[{".class":"TypeType","item":"builtins.object"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyCallable"}],"extra_attrs":null,"type_ref":"builtins.dict"}],["underscore_attrs_are_private","builtins.bool"],["allow_inf_nan","builtins.bool"],["copy_on_model_validation",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"none"},{".class":"LiteralType","fallback":"builtins.str","value":"deep"},{".class":"LiteralType","fallback":"builtins.str","value":"shallow"}],"uses_pep604_syntax":false}],["post_init_call",{".class":"UnionType","items":[{".class":"LiteralType","fallback":"builtins.str","value":"before_validation"},{".class":"LiteralType","fallback":"builtins.str","value":"after_validation"}],"uses_pep604_syntax":false}]],"readonly_keys":[],"required_keys":[]}}},"ConfigType":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.config.ConfigType","line":17,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"TypeType","item":"pydantic.v1.config.BaseConfig"}}},"Dict":{".class":"SymbolTableNode","cross_ref":"typing.Dict","kind":"Gdef","module_public":false},"Enum":{".class":"SymbolTableNode","cross_ref":"enum.Enum","kind":"Gdef","module_public":false},"Extra":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.str","enum.Enum"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.config.Extra","name":"Extra","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_enum"],"fullname":"pydantic.v1.config.Extra","has_param_spec_type":false,"metaclass_type":"enum.EnumMeta","metadata":{},"module_name":"pydantic.v1.config","mro":["pydantic.v1.config.Extra","builtins.str","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","enum.Enum","builtins.object"],"names":{".class":"SymbolTable","allow":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.config.Extra.allow","name":"allow","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.str","value":"allow"},"type_ref":"builtins.str"}}},"forbid":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.config.Extra.forbid","name":"forbid","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.str","value":"forbid"},"type_ref":"builtins.str"}}},"ignore":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.config.Extra.ignore","name":"ignore","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.str","value":"ignore"},"type_ref":"builtins.str"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.config.Extra.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.config.Extra","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ForwardRef":{".class":"SymbolTableNode","cross_ref":"typing.ForwardRef","kind":"Gdef","module_public":false},"GetterDict":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.GetterDict","kind":"Gdef","module_public":false},"Literal":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Literal","kind":"Gdef","module_public":false},"ModelField":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.fields.ModelField","kind":"Gdef","module_public":false},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef","module_public":false},"Protocol":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Protocol","kind":"Gdef","module_public":false},"SchemaExtraCallable":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[["__call__",1]],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.config.SchemaExtraCallable","name":"SchemaExtraCallable","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_abstract","is_protocol"],"fullname":"pydantic.v1.config.SchemaExtraCallable","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic.v1.config","mro":["pydantic.v1.config.SchemaExtraCallable","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"pydantic.v1.config.SchemaExtraCallable.__call__","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":1,"arg_kinds":[0,0],"arg_names":["self","schema"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self","is_mypy_only"],"fullname":"pydantic.v1.config.SchemaExtraCallable.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","schema"],"arg_types":["pydantic.v1.config.SchemaExtraCallable",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of SchemaExtraCallable","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.config.SchemaExtraCallable.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","schema"],"arg_types":["pydantic.v1.config.SchemaExtraCallable",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of SchemaExtraCallable","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":1,"arg_kinds":[0,0,0],"arg_names":["self","schema","model_class"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self","is_mypy_only"],"fullname":"pydantic.v1.config.SchemaExtraCallable.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","schema","model_class"],"arg_types":["pydantic.v1.config.SchemaExtraCallable",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"TypeType","item":"pydantic.v1.main.BaseModel"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of SchemaExtraCallable","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.config.SchemaExtraCallable.__call__","name":"__call__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","schema","model_class"],"arg_types":["pydantic.v1.config.SchemaExtraCallable",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"TypeType","item":"pydantic.v1.main.BaseModel"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of SchemaExtraCallable","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","schema"],"arg_types":["pydantic.v1.config.SchemaExtraCallable",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of SchemaExtraCallable","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","schema","model_class"],"arg_types":["pydantic.v1.config.SchemaExtraCallable",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"TypeType","item":"pydantic.v1.main.BaseModel"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of SchemaExtraCallable","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.config.SchemaExtraCallable.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.config.SchemaExtraCallable","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef","module_public":false},"Tuple":{".class":"SymbolTableNode","cross_ref":"typing.Tuple","kind":"Gdef","module_public":false},"Type":{".class":"SymbolTableNode","cross_ref":"typing.Type","kind":"Gdef","module_public":false},"TypedDict":{".class":"SymbolTableNode","cross_ref":"typing.TypedDict","kind":"Gdef","module_public":false},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef","module_public":false},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.config.__all__","name":"__all__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.config.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.config.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.config.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.config.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.config.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.config.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"compiled":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.version.compiled","kind":"Gdef","module_public":false},"get_config":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["config"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.config.get_config","name":"get_config","original_first_arg":"config","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["config"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.config.ConfigDict"},{".class":"TypeType","item":"builtins.object"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_config","ret_type":{".class":"TypeType","item":"pydantic.v1.config.BaseConfig"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"inherit_config":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,4],"arg_names":["self_config","parent_config","namespace"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.config.inherit_config","name":"inherit_config","original_first_arg":"self_config","type":{".class":"CallableType","arg_kinds":[0,0,4],"arg_names":["self_config","parent_config","namespace"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.config.ConfigType"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.config.ConfigType"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"inherit_config","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.config.ConfigType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"json":{".class":"SymbolTableNode","cross_ref":"json","kind":"Gdef","module_public":false},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_public":false},"prepare_config":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["config","cls_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.config.prepare_config","name":"prepare_config","original_first_arg":"config","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["config","cls_name"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.config.BaseConfig"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prepare_config","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/config.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/config.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/config.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..9619115e154e4a222e87f49c38c72766a2409cfd --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/config.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[7,8,9,14,15,1,2,3,5,1,1,1,1,1,1],"dep_prios":[5,5,5,25,25,10,5,5,5,5,30,30,30,30,30],"dependencies":["pydantic.v1.typing","pydantic.v1.utils","pydantic.v1.version","pydantic.v1.fields","pydantic.v1.main","json","enum","typing","typing_extensions","builtins","_frozen_importlib","_typeshed","abc","json.decoder","json.encoder"],"hash":"6581db36b9f61bed44ed1870e4f551529b9da21e","id":"pydantic.v1.config","ignore_all":true,"interface_hash":"b074d423f0dd4f401c017f6b81514d1d66cc2fc8","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/config.py","plugin_data":null,"size":6532,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/dataclasses.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/dataclasses.data.json new file mode 100644 index 0000000000000000000000000000000000000000..30bf1c9c20c1f6d5545eb3a0a39106d2acd873a2 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/dataclasses.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic.v1.dataclasses","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_public":false},"BaseConfig":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.config.BaseConfig","kind":"Gdef","module_public":false},"BaseModel":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.main.BaseModel","kind":"Gdef","module_public":false},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef","module_public":false},"CallableGenerator":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.CallableGenerator","kind":"Gdef","module_public":false},"ClassAttribute":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.ClassAttribute","kind":"Gdef","module_public":false},"ClassVar":{".class":"SymbolTableNode","cross_ref":"typing.ClassVar","kind":"Gdef","module_public":false},"ConfigDict":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.config.ConfigDict","kind":"Gdef","module_public":false},"Dataclass":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.dataclasses.Dataclass","name":"Dataclass","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.dataclasses.Dataclass","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.dataclasses","mro":["pydantic.v1.dataclasses.Dataclass","builtins.object"],"names":{".class":"SymbolTable","__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready"],"fullname":"pydantic.v1.dataclasses.Dataclass.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__dataclass_params__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready"],"fullname":"pydantic.v1.dataclasses.Dataclass.__dataclass_params__","name":"__dataclass_params__","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"__get_validators__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_mypy_only"],"fullname":"pydantic.v1.dataclasses.Dataclass.__get_validators__","name":"__get_validators__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.dataclasses.Dataclass"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of Dataclass","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.dataclasses.Dataclass.__get_validators__","name":"__get_validators__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.dataclasses.Dataclass"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of Dataclass","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self","is_mypy_only"],"fullname":"pydantic.v1.dataclasses.Dataclass.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"arg_types":["pydantic.v1.dataclasses.Dataclass","builtins.object","builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of Dataclass","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__post_init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready"],"fullname":"pydantic.v1.dataclasses.Dataclass.__post_init__","name":"__post_init__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__post_init_post_parse__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready"],"fullname":"pydantic.v1.dataclasses.Dataclass.__post_init_post_parse__","name":"__post_init_post_parse__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__pydantic_has_field_info_default__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready"],"fullname":"pydantic.v1.dataclasses.Dataclass.__pydantic_has_field_info_default__","name":"__pydantic_has_field_info_default__","setter_type":null,"type":"builtins.bool"}},"__pydantic_initialised__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready"],"fullname":"pydantic.v1.dataclasses.Dataclass.__pydantic_initialised__","name":"__pydantic_initialised__","setter_type":null,"type":"builtins.bool"}},"__pydantic_model__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready"],"fullname":"pydantic.v1.dataclasses.Dataclass.__pydantic_model__","name":"__pydantic_model__","setter_type":null,"type":{".class":"TypeType","item":"pydantic.v1.main.BaseModel"}}},"__pydantic_run_validation__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready"],"fullname":"pydantic.v1.dataclasses.Dataclass.__pydantic_run_validation__","name":"__pydantic_run_validation__","setter_type":null,"type":"builtins.bool"}},"__pydantic_validate_values__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready"],"fullname":"pydantic.v1.dataclasses.Dataclass.__pydantic_validate_values__","name":"__pydantic_validate_values__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["pydantic.v1.dataclasses.Dataclass"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__validate__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","v"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_mypy_only"],"fullname":"pydantic.v1.dataclasses.Dataclass.__validate__","name":"__validate__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","v"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses.DataclassT","id":-1,"name":"DataclassT","namespace":"pydantic.v1.dataclasses.Dataclass.__validate__","upper_bound":"pydantic.v1.dataclasses.Dataclass","values":[],"variance":0}},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__validate__ of Dataclass","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses.DataclassT","id":-1,"name":"DataclassT","namespace":"pydantic.v1.dataclasses.Dataclass.__validate__","upper_bound":"pydantic.v1.dataclasses.Dataclass","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses.DataclassT","id":-1,"name":"DataclassT","namespace":"pydantic.v1.dataclasses.Dataclass.__validate__","upper_bound":"pydantic.v1.dataclasses.Dataclass","values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.dataclasses.Dataclass.__validate__","name":"__validate__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","v"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses.DataclassT","id":-1,"name":"DataclassT","namespace":"pydantic.v1.dataclasses.Dataclass.__validate__","upper_bound":"pydantic.v1.dataclasses.Dataclass","values":[],"variance":0}},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__validate__ of Dataclass","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses.DataclassT","id":-1,"name":"DataclassT","namespace":"pydantic.v1.dataclasses.Dataclass.__validate__","upper_bound":"pydantic.v1.dataclasses.Dataclass","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses.DataclassT","id":-1,"name":"DataclassT","namespace":"pydantic.v1.dataclasses.Dataclass.__validate__","upper_bound":"pydantic.v1.dataclasses.Dataclass","values":[],"variance":0}]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses.Dataclass.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.dataclasses.Dataclass","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"DataclassClassOrWrapper":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.dataclasses.DataclassClassOrWrapper","line":64,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"TypeType","item":"pydantic.v1.dataclasses.Dataclass"},"pydantic.v1.dataclasses.DataclassProxy"],"uses_pep604_syntax":false}}},"DataclassProxy":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.dataclasses.DataclassProxy","name":"DataclassProxy","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.dataclasses.DataclassProxy","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.dataclasses","mro":["pydantic.v1.dataclasses.DataclassProxy","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.dataclasses.DataclassProxy.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"arg_types":["pydantic.v1.dataclasses.DataclassProxy",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of DataclassProxy","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__copy__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.dataclasses.DataclassProxy.__copy__","name":"__copy__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.dataclasses.DataclassProxy"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__copy__ of DataclassProxy","ret_type":"pydantic.v1.dataclasses.DataclassProxy","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__deepcopy__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","memo"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.dataclasses.DataclassProxy.__deepcopy__","name":"__deepcopy__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","memo"],"arg_types":["pydantic.v1.dataclasses.DataclassProxy",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__deepcopy__ of DataclassProxy","ret_type":"pydantic.v1.dataclasses.DataclassProxy","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__getattr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.dataclasses.DataclassProxy.__getattr__","name":"__getattr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["pydantic.v1.dataclasses.DataclassProxy","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getattr__ of DataclassProxy","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","dc_cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.dataclasses.DataclassProxy.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","dc_cls"],"arg_types":["pydantic.v1.dataclasses.DataclassProxy",{".class":"TypeType","item":"pydantic.v1.dataclasses.Dataclass"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of DataclassProxy","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__instancecheck__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","instance"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.dataclasses.DataclassProxy.__instancecheck__","name":"__instancecheck__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","instance"],"arg_types":["pydantic.v1.dataclasses.DataclassProxy",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__instancecheck__ of DataclassProxy","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__setattr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self",null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.dataclasses.DataclassProxy.__setattr__","name":"__setattr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self",null,null],"arg_types":["pydantic.v1.dataclasses.DataclassProxy","builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__setattr__ of DataclassProxy","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic.v1.dataclasses.DataclassProxy.__slots__","name":"__slots__","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses.DataclassProxy.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.dataclasses.DataclassProxy","values":[],"variance":0},"slots":["__dataclass__"],"tuple_type":null,"type_vars":[],"typeddict_type":null}},"DataclassT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses.DataclassT","name":"DataclassT","upper_bound":"pydantic.v1.dataclasses.Dataclass","values":[],"variance":0}},"DataclassTypeError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.DataclassTypeError","kind":"Gdef","module_public":false},"Dict":{".class":"SymbolTableNode","cross_ref":"typing.Dict","kind":"Gdef","module_public":false},"Extra":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.config.Extra","kind":"Gdef","module_public":false},"Field":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.fields.Field","kind":"Gdef","module_public":false},"FieldInfo":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.fields.FieldInfo","kind":"Gdef","module_public":false},"Generator":{".class":"SymbolTableNode","cross_ref":"typing.Generator","kind":"Gdef","module_public":false},"NoArgAnyCallable":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.NoArgAnyCallable","kind":"Gdef","module_public":false},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef","module_public":false},"Required":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.fields.Required","kind":"Gdef","module_public":false},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef","module_public":false},"Type":{".class":"SymbolTableNode","cross_ref":"typing.Type","kind":"Gdef","module_public":false},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_public":false},"Undefined":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.fields.Undefined","kind":"Gdef","module_public":false},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef","module_public":false},"ValidationError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.error_wrappers.ValidationError","kind":"Gdef","module_public":false},"_T":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses._T","name":"_T","upper_bound":"builtins.object","values":[],"variance":0}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.dataclasses.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.dataclasses.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.dataclasses.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.dataclasses.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.dataclasses.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.dataclasses.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.dataclasses.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_add_pydantic_validation_attributes":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["dc_cls","config","validate_on_init","dc_cls_doc"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.dataclasses._add_pydantic_validation_attributes","name":"_add_pydantic_validation_attributes","original_first_arg":"dc_cls","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["dc_cls","config","validate_on_init","dc_cls_doc"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.dataclasses.Dataclass"},{".class":"TypeType","item":"pydantic.v1.config.BaseConfig"},"builtins.bool","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_add_pydantic_validation_attributes","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_dataclass_validate_assignment_setattr":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","name","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.dataclasses._dataclass_validate_assignment_setattr","name":"_dataclass_validate_assignment_setattr","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","name","value"],"arg_types":["pydantic.v1.dataclasses.Dataclass","builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_dataclass_validate_assignment_setattr","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_dataclass_validate_values":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.dataclasses._dataclass_validate_values","name":"_dataclass_validate_values","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.dataclasses.Dataclass"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_dataclass_validate_values","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_get_validators":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.dataclasses._get_validators","name":"_get_validators","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.dataclasses.DataclassClassOrWrapper"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_validators","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_is_field_cached_property":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["obj","k"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.dataclasses._is_field_cached_property","name":"_is_field_cached_property","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["obj","k"],"arg_types":["pydantic.v1.dataclasses.Dataclass","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_is_field_cached_property","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_validate_dataclass":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.dataclasses._validate_dataclass","name":"_validate_dataclass","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","v"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses.DataclassT","id":-1,"name":"DataclassT","namespace":"pydantic.v1.dataclasses._validate_dataclass","upper_bound":"pydantic.v1.dataclasses.Dataclass","values":[],"variance":0}},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_validate_dataclass","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses.DataclassT","id":-1,"name":"DataclassT","namespace":"pydantic.v1.dataclasses._validate_dataclass","upper_bound":"pydantic.v1.dataclasses.Dataclass","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses.DataclassT","id":-1,"name":"DataclassT","namespace":"pydantic.v1.dataclasses._validate_dataclass","upper_bound":"pydantic.v1.dataclasses.Dataclass","values":[],"variance":0}]}}},"cached_property":{".class":"SymbolTableNode","cross_ref":"functools.cached_property","kind":"Gdef","module_public":false},"contextmanager":{".class":"SymbolTableNode","cross_ref":"contextlib.contextmanager","kind":"Gdef","module_public":false},"copy":{".class":"SymbolTableNode","cross_ref":"copy","kind":"Gdef","module_public":false},"create_model":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.main.create_model","kind":"Gdef","module_public":false},"create_pydantic_model_from_dataclass":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["dc_cls","config","dc_cls_doc"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.dataclasses.create_pydantic_model_from_dataclass","name":"create_pydantic_model_from_dataclass","original_first_arg":"dc_cls","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["dc_cls","config","dc_cls_doc"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.dataclasses.Dataclass"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"create_pydantic_model_from_dataclass","ret_type":{".class":"TypeType","item":"pydantic.v1.main.BaseModel"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"dataclass":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"pydantic.v1.dataclasses.dataclass","impl":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1,5,5,5,5,5,5,5,5,5,5],"arg_names":["_cls","init","repr","eq","order","unsafe_hash","frozen","config","validate_on_init","use_proxy","kw_only"],"dataclass_transform_spec":{"eq_default":true,"field_specifiers":["dataclasses.field","pydantic.v1.fields.Field"],"frozen_default":false,"kw_only_default":false,"order_default":false},"deprecated":null,"flags":["is_decorated"],"fullname":"pydantic.v1.dataclasses.dataclass","name":"dataclass","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[1,5,5,5,5,5,5,5,5,5,5],"arg_names":["_cls","init","repr","eq","order","unsafe_hash","frozen","config","validate_on_init","use_proxy","kw_only"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses._T","id":-1,"name":"_T","namespace":"pydantic.v1.dataclasses.dataclass","upper_bound":"builtins.object","values":[],"variance":0}},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool","builtins.bool","builtins.bool","builtins.bool","builtins.bool","builtins.bool",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.config.ConfigDict"},{".class":"TypeType","item":"builtins.object"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dataclass","ret_type":{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses._T","id":-1,"name":"_T","namespace":"pydantic.v1.dataclasses.dataclass","upper_bound":"builtins.object","values":[],"variance":0}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.dataclasses.DataclassClassOrWrapper"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.dataclasses.DataclassClassOrWrapper"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses._T","id":-1,"name":"_T","namespace":"pydantic.v1.dataclasses.dataclass","upper_bound":"builtins.object","values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.dataclasses.dataclass","name":"dataclass","setter_type":null,"type":{".class":"CallableType","arg_kinds":[1,5,5,5,5,5,5,5,5,5,5],"arg_names":["_cls","init","repr","eq","order","unsafe_hash","frozen","config","validate_on_init","use_proxy","kw_only"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses._T","id":-1,"name":"_T","namespace":"pydantic.v1.dataclasses.dataclass","upper_bound":"builtins.object","values":[],"variance":0}},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool","builtins.bool","builtins.bool","builtins.bool","builtins.bool","builtins.bool",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.config.ConfigDict"},{".class":"TypeType","item":"builtins.object"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dataclass","ret_type":{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses._T","id":-1,"name":"_T","namespace":"pydantic.v1.dataclasses.dataclass","upper_bound":"builtins.object","values":[],"variance":0}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.dataclasses.DataclassClassOrWrapper"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.dataclasses.DataclassClassOrWrapper"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses._T","id":-1,"name":"_T","namespace":"pydantic.v1.dataclasses.dataclass","upper_bound":"builtins.object","values":[],"variance":0}]}}},"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5,5,5,5],"arg_names":["init","repr","eq","order","unsafe_hash","frozen","config","validate_on_init","use_proxy"],"dataclass_transform_spec":{"eq_default":true,"field_specifiers":["dataclasses.field","pydantic.v1.fields.Field"],"frozen_default":false,"kw_only_default":false,"order_default":false},"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"pydantic.v1.dataclasses.dataclass","name":"dataclass","original_first_arg":"init","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5,5,5],"arg_names":["init","repr","eq","order","unsafe_hash","frozen","config","validate_on_init","use_proxy"],"arg_types":["builtins.bool","builtins.bool","builtins.bool","builtins.bool","builtins.bool","builtins.bool",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.config.ConfigDict"},{".class":"TypeType","item":"builtins.object"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dataclass","ret_type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses._T","id":-1,"name":"_T","namespace":"","upper_bound":"builtins.object","values":[],"variance":0}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.dataclasses.DataclassClassOrWrapper"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses._T","id":-1,"name":"_T","namespace":"","upper_bound":"builtins.object","values":[],"variance":0}]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.dataclasses.dataclass","name":"dataclass","setter_type":null,"type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5,5,5],"arg_names":["init","repr","eq","order","unsafe_hash","frozen","config","validate_on_init","use_proxy"],"arg_types":["builtins.bool","builtins.bool","builtins.bool","builtins.bool","builtins.bool","builtins.bool",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.config.ConfigDict"},{".class":"TypeType","item":"builtins.object"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dataclass","ret_type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses._T","id":-1,"name":"_T","namespace":"","upper_bound":"builtins.object","values":[],"variance":0}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.dataclasses.DataclassClassOrWrapper"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses._T","id":-1,"name":"_T","namespace":"","upper_bound":"builtins.object","values":[],"variance":0}]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5,5,5,5,5,5],"arg_names":["_cls","init","repr","eq","order","unsafe_hash","frozen","config","validate_on_init","use_proxy"],"dataclass_transform_spec":{"eq_default":true,"field_specifiers":["dataclasses.field","pydantic.v1.fields.Field"],"frozen_default":false,"kw_only_default":false,"order_default":false},"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"pydantic.v1.dataclasses.dataclass","name":"dataclass","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5,5,5,5,5,5],"arg_names":["_cls","init","repr","eq","order","unsafe_hash","frozen","config","validate_on_init","use_proxy"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses._T","id":-1,"name":"_T","namespace":"pydantic.v1.dataclasses.dataclass#1","upper_bound":"builtins.object","values":[],"variance":0}},"builtins.bool","builtins.bool","builtins.bool","builtins.bool","builtins.bool","builtins.bool",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.config.ConfigDict"},{".class":"TypeType","item":"builtins.object"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dataclass","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.dataclasses.DataclassClassOrWrapper"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses._T","id":-1,"name":"_T","namespace":"pydantic.v1.dataclasses.dataclass#1","upper_bound":"builtins.object","values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.dataclasses.dataclass","name":"dataclass","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5,5,5,5,5,5,5,5],"arg_names":["_cls","init","repr","eq","order","unsafe_hash","frozen","config","validate_on_init","use_proxy"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses._T","id":-1,"name":"_T","namespace":"pydantic.v1.dataclasses.dataclass#1","upper_bound":"builtins.object","values":[],"variance":0}},"builtins.bool","builtins.bool","builtins.bool","builtins.bool","builtins.bool","builtins.bool",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.config.ConfigDict"},{".class":"TypeType","item":"builtins.object"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dataclass","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.dataclasses.DataclassClassOrWrapper"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses._T","id":-1,"name":"_T","namespace":"pydantic.v1.dataclasses.dataclass#1","upper_bound":"builtins.object","values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5,5,5],"arg_names":["init","repr","eq","order","unsafe_hash","frozen","config","validate_on_init","use_proxy"],"arg_types":["builtins.bool","builtins.bool","builtins.bool","builtins.bool","builtins.bool","builtins.bool",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.config.ConfigDict"},{".class":"TypeType","item":"builtins.object"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dataclass","ret_type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses._T","id":-1,"name":"_T","namespace":"","upper_bound":"builtins.object","values":[],"variance":0}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.dataclasses.DataclassClassOrWrapper"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses._T","id":-1,"name":"_T","namespace":"","upper_bound":"builtins.object","values":[],"variance":0}]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,5,5,5,5,5,5,5,5,5],"arg_names":["_cls","init","repr","eq","order","unsafe_hash","frozen","config","validate_on_init","use_proxy"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses._T","id":-1,"name":"_T","namespace":"pydantic.v1.dataclasses.dataclass#1","upper_bound":"builtins.object","values":[],"variance":0}},"builtins.bool","builtins.bool","builtins.bool","builtins.bool","builtins.bool","builtins.bool",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.config.ConfigDict"},{".class":"TypeType","item":"builtins.object"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dataclass","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.dataclasses.DataclassClassOrWrapper"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses._T","id":-1,"name":"_T","namespace":"pydantic.v1.dataclasses.dataclass#1","upper_bound":"builtins.object","values":[],"variance":0}]}]}}},"dataclass_transform":{".class":"SymbolTableNode","cross_ref":"typing_extensions.dataclass_transform","kind":"Gdef","module_public":false},"dataclasses":{".class":"SymbolTableNode","cross_ref":"dataclasses","kind":"Gdef","module_public":false},"gather_all_validators":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.class_validators.gather_all_validators","kind":"Gdef","module_public":false},"get_config":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.config.get_config","kind":"Gdef","module_public":false},"is_builtin_dataclass":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["_cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.dataclasses.is_builtin_dataclass","name":"is_builtin_dataclass","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["_cls"],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_builtin_dataclass","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"make_dataclass_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["dc_cls","config"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.dataclasses.make_dataclass_validator","name":"make_dataclass_validator","original_first_arg":"dc_cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["dc_cls","config"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.dataclasses.Dataclass"},{".class":"TypeType","item":"pydantic.v1.config.BaseConfig"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"make_dataclass_validator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_public":false},"set_validation":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated"],"fullname":"pydantic.v1.dataclasses.set_validation","name":"set_validation","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","value"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses.DataclassT","id":-1,"name":"DataclassT","namespace":"pydantic.v1.dataclasses.set_validation","upper_bound":"pydantic.v1.dataclasses.Dataclass","values":[],"variance":0}},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"set_validation","ret_type":{".class":"Instance","args":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses.DataclassT","id":-1,"name":"DataclassT","namespace":"pydantic.v1.dataclasses.set_validation","upper_bound":"pydantic.v1.dataclasses.Dataclass","values":[],"variance":0}},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Generator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses.DataclassT","id":-1,"name":"DataclassT","namespace":"pydantic.v1.dataclasses.set_validation","upper_bound":"pydantic.v1.dataclasses.Dataclass","values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.dataclasses.set_validation","name":"set_validation","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","value"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses.DataclassT","id":-1,"name":"DataclassT","namespace":"pydantic.v1.dataclasses.set_validation","upper_bound":"pydantic.v1.dataclasses.Dataclass","values":[],"variance":0}},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"set_validation","ret_type":{".class":"Instance","args":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses.DataclassT","id":-1,"name":"DataclassT","namespace":"pydantic.v1.dataclasses.set_validation","upper_bound":"pydantic.v1.dataclasses.Dataclass","values":[],"variance":0}},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"contextlib._GeneratorContextManager"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.dataclasses.DataclassT","id":-1,"name":"DataclassT","namespace":"pydantic.v1.dataclasses.set_validation","upper_bound":"pydantic.v1.dataclasses.Dataclass","values":[],"variance":0}]}}}},"sys":{".class":"SymbolTableNode","cross_ref":"sys","kind":"Gdef","module_public":false},"validate_model":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.main.validate_model","kind":"Gdef","module_public":false},"wraps":{".class":"SymbolTableNode","cross_ref":"functools.wraps","kind":"Gdef","module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/dataclasses.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/dataclasses.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/dataclasses.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..b1b5d877bf16cdb06f9225fd8ec75b7306a2bb1a --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/dataclasses.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[50,51,52,53,54,55,56,60,34,35,36,37,38,46,48,1,1,1,1,1],"dep_prios":[5,5,5,5,5,5,5,25,10,10,10,5,5,5,5,5,30,30,30,30],"dependencies":["pydantic.v1.class_validators","pydantic.v1.config","pydantic.v1.error_wrappers","pydantic.v1.errors","pydantic.v1.fields","pydantic.v1.main","pydantic.v1.utils","pydantic.v1.typing","copy","dataclasses","sys","contextlib","functools","typing","typing_extensions","builtins","_frozen_importlib","_typeshed","abc","enum"],"hash":"f9117863bbd534cd907ccbc2981dc79a384b6df4","id":"pydantic.v1.dataclasses","ignore_all":true,"interface_hash":"ebf4340cfceb96283143cce51b59ef6f1e358609","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/dataclasses.py","plugin_data":null,"size":18172,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/datetime_parse.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/datetime_parse.data.json new file mode 100644 index 0000000000000000000000000000000000000000..e830764fcb82e39774a7837f2ec861786a016a8d --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/datetime_parse.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic.v1.datetime_parse","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Dict":{".class":"SymbolTableNode","cross_ref":"typing.Dict","kind":"Gdef"},"EPOCH":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.datetime_parse.EPOCH","name":"EPOCH","setter_type":null,"type":"datetime.datetime"}},"MAX_NUMBER":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.datetime_parse.MAX_NUMBER","name":"MAX_NUMBER","setter_type":null,"type":"builtins.int"}},"MS_WATERSHED":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.datetime_parse.MS_WATERSHED","name":"MS_WATERSHED","setter_type":null,"type":"builtins.int"}},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"StrBytesIntFloat":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic.v1.datetime_parse.StrBytesIntFloat","line":63,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["builtins.str","builtins.bytes","builtins.int","builtins.float"],"uses_pep604_syntax":false}}},"Type":{".class":"SymbolTableNode","cross_ref":"typing.Type","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.datetime_parse.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.datetime_parse.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.datetime_parse.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.datetime_parse.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.datetime_parse.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.datetime_parse.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_parse_timezone":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["value","error"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.datetime_parse._parse_timezone","name":"_parse_timezone","original_first_arg":"value","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["value","error"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"TypeType","item":"builtins.Exception"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_parse_timezone","ret_type":{".class":"UnionType","items":[{".class":"NoneType"},"builtins.int","datetime.timezone"],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"date":{".class":"SymbolTableNode","cross_ref":"datetime.date","kind":"Gdef"},"date_expr":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.datetime_parse.date_expr","name":"date_expr","setter_type":null,"type":"builtins.str"}},"date_re":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.datetime_parse.date_re","name":"date_re","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"datetime":{".class":"SymbolTableNode","cross_ref":"datetime.datetime","kind":"Gdef"},"datetime_re":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.datetime_parse.datetime_re","name":"datetime_re","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"errors":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors","kind":"Gdef"},"from_unix_seconds":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["seconds"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.datetime_parse.from_unix_seconds","name":"from_unix_seconds","original_first_arg":"seconds","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["seconds"],"arg_types":[{".class":"UnionType","items":["builtins.int","builtins.float"],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"from_unix_seconds","ret_type":"datetime.datetime","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_numeric":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["value","native_expected_type"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.datetime_parse.get_numeric","name":"get_numeric","original_first_arg":"value","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["value","native_expected_type"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.datetime_parse.StrBytesIntFloat"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_numeric","ret_type":{".class":"UnionType","items":[{".class":"NoneType"},"builtins.int","builtins.float"],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"iso8601_duration_re":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.datetime_parse.iso8601_duration_re","name":"iso8601_duration_re","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"parse_date":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["value"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.datetime_parse.parse_date","name":"parse_date","original_first_arg":"value","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["value"],"arg_types":[{".class":"UnionType","items":["datetime.date",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.datetime_parse.StrBytesIntFloat"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parse_date","ret_type":"datetime.date","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"parse_datetime":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["value"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.datetime_parse.parse_datetime","name":"parse_datetime","original_first_arg":"value","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["value"],"arg_types":[{".class":"UnionType","items":["datetime.datetime",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.datetime_parse.StrBytesIntFloat"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parse_datetime","ret_type":"datetime.datetime","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"parse_duration":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["value"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.datetime_parse.parse_duration","name":"parse_duration","original_first_arg":"value","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["value"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.datetime_parse.StrBytesIntFloat"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parse_duration","ret_type":"datetime.timedelta","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"parse_time":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["value"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.datetime_parse.parse_time","name":"parse_time","original_first_arg":"value","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["value"],"arg_types":[{".class":"UnionType","items":["datetime.time",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.datetime_parse.StrBytesIntFloat"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parse_time","ret_type":"datetime.time","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef"},"standard_duration_re":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.datetime_parse.standard_duration_re","name":"standard_duration_re","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"time":{".class":"SymbolTableNode","cross_ref":"datetime.time","kind":"Gdef"},"time_expr":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.datetime_parse.time_expr","name":"time_expr","setter_type":null,"type":"builtins.str"}},"time_re":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.datetime_parse.time_re","name":"time_re","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"timedelta":{".class":"SymbolTableNode","cross_ref":"datetime.timedelta","kind":"Gdef"},"timezone":{".class":"SymbolTableNode","cross_ref":"datetime.timezone","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/datetime_parse.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/datetime_parse.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/datetime_parse.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..fe06b9de78977c7f8c7997707f70e87cd30a2565 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/datetime_parse.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[21,21,17,18,19,1,1,1,1,1,1],"dep_prios":[10,20,10,5,5,5,30,30,30,30,30],"dependencies":["pydantic.v1.errors","pydantic.v1","re","datetime","typing","builtins","_frozen_importlib","_typeshed","abc","enum","typing_extensions"],"hash":"1a8c435b63cb82890590dd06b1f2e054e4d83bed","id":"pydantic.v1.datetime_parse","ignore_all":true,"interface_hash":"3415f0c389d9b3e6ef8cfffcfd5a99b85ef82abb","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/datetime_parse.py","plugin_data":null,"size":7724,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/decorator.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/decorator.data.json new file mode 100644 index 0000000000000000000000000000000000000000..4fa1aba63dff729e59ba37e3b9b3ebc0c8680ee4 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/decorator.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic.v1.decorator","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","ALT_V_ARGS":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.decorator.ALT_V_ARGS","name":"ALT_V_ARGS","setter_type":null,"type":"builtins.str"}},"ALT_V_KWARGS":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.decorator.ALT_V_KWARGS","name":"ALT_V_KWARGS","setter_type":null,"type":"builtins.str"}},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_public":false},"AnyCallable":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.AnyCallable","kind":"Gdef","module_public":false},"AnyCallableT":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.decorator.AnyCallableT","name":"AnyCallableT","upper_bound":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"values":[],"variance":0}},"BaseModel":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.main.BaseModel","kind":"Gdef","module_public":false},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef","module_public":false},"Config":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.decorator.DecoratorBaseModel@226.Config","kind":"Gdef"},"ConfigError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.ConfigError","kind":"Gdef","module_public":false},"ConfigType":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.decorator.ConfigType","line":17,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"NoneType"},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false}}},"CustomConfig@211":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.decorator.CustomConfig@211","name":"CustomConfig","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.decorator.CustomConfig@211","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.decorator","mro":["pydantic.v1.decorator.CustomConfig@211","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.decorator.CustomConfig@211.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.decorator.CustomConfig@211","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"DecoratorBaseModel@226":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.main.BaseModel"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.decorator.DecoratorBaseModel@226","name":"DecoratorBaseModel","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.decorator.DecoratorBaseModel@226","has_param_spec_type":false,"metaclass_type":"pydantic.v1.main.ModelMetaclass","metadata":{"dataclass":{"attributes":[],"frozen":false},"dataclass_tag":{}},"module_name":"pydantic.v1.decorator","mro":["pydantic.v1.decorator.DecoratorBaseModel@226","pydantic.v1.main.BaseModel","pydantic.v1.utils.Representation","builtins.object"],"names":{".class":"SymbolTable","Config":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.decorator.CustomConfig@211"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.decorator.DecoratorBaseModel@226.Config","name":"Config","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.decorator.DecoratorBaseModel@226.Config","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.decorator","mro":["pydantic.v1.decorator.DecoratorBaseModel@226.Config","pydantic.v1.decorator.CustomConfig@211","builtins.object"],"names":{".class":"SymbolTable","extra":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.decorator.DecoratorBaseModel@226.Config.extra","name":"extra","setter_type":null,"type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"pydantic.v1.config.Extra"],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.decorator.DecoratorBaseModel@226.Config.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.decorator.DecoratorBaseModel@226.Config","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"pydantic.v1.decorator.DecoratorBaseModel@226.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"pydantic.v1.decorator.DecoratorBaseModel@226.__mypy-replace","name":"__mypy-replace","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of DecoratorBaseModel","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"pydantic.v1.decorator.DecoratorBaseModel@226.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of DecoratorBaseModel","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"check_args":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","v"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated","is_trivial_self"],"fullname":"pydantic.v1.decorator.DecoratorBaseModel@226.check_args","name":"check_args","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","v"],"arg_types":["pydantic.v1.decorator.DecoratorBaseModel@226",{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"check_args of DecoratorBaseModel","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred"],"fullname":"pydantic.v1.decorator.DecoratorBaseModel@226.check_args","name":"check_args","setter_type":null,"type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.classmethod"}}}},"check_duplicate_kwargs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","v"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated","is_trivial_self"],"fullname":"pydantic.v1.decorator.DecoratorBaseModel@226.check_duplicate_kwargs","name":"check_duplicate_kwargs","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","v"],"arg_types":["pydantic.v1.decorator.DecoratorBaseModel@226",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"check_duplicate_kwargs of DecoratorBaseModel","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred"],"fullname":"pydantic.v1.decorator.DecoratorBaseModel@226.check_duplicate_kwargs","name":"check_duplicate_kwargs","setter_type":null,"type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.classmethod"}}}},"check_kwargs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","v"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated","is_trivial_self"],"fullname":"pydantic.v1.decorator.DecoratorBaseModel@226.check_kwargs","name":"check_kwargs","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","v"],"arg_types":["pydantic.v1.decorator.DecoratorBaseModel@226",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"check_kwargs of DecoratorBaseModel","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred"],"fullname":"pydantic.v1.decorator.DecoratorBaseModel@226.check_kwargs","name":"check_kwargs","setter_type":null,"type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.classmethod"}}}},"check_positional_only":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","v"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated","is_trivial_self"],"fullname":"pydantic.v1.decorator.DecoratorBaseModel@226.check_positional_only","name":"check_positional_only","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","v"],"arg_types":["pydantic.v1.decorator.DecoratorBaseModel@226",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"check_positional_only of DecoratorBaseModel","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred"],"fullname":"pydantic.v1.decorator.DecoratorBaseModel@226.check_positional_only","name":"check_positional_only","setter_type":null,"type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.classmethod"}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.decorator.DecoratorBaseModel@226.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.decorator.DecoratorBaseModel@226","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Dict":{".class":"SymbolTableNode","cross_ref":"typing.Dict","kind":"Gdef","module_public":false},"Extra":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.config.Extra","kind":"Gdef","module_public":false},"List":{".class":"SymbolTableNode","cross_ref":"typing.List","kind":"Gdef","module_public":false},"Mapping":{".class":"SymbolTableNode","cross_ref":"typing.Mapping","kind":"Gdef","module_public":false},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef","module_public":false},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef","module_public":false},"Tuple":{".class":"SymbolTableNode","cross_ref":"typing.Tuple","kind":"Gdef","module_public":false},"Type":{".class":"SymbolTableNode","cross_ref":"typing.Type","kind":"Gdef","module_public":false},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_public":false},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef","module_public":false},"V_DUPLICATE_KWARGS":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.decorator.V_DUPLICATE_KWARGS","name":"V_DUPLICATE_KWARGS","setter_type":null,"type":"builtins.str"}},"V_POSITIONAL_ONLY_NAME":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.decorator.V_POSITIONAL_ONLY_NAME","name":"V_POSITIONAL_ONLY_NAME","setter_type":null,"type":"builtins.str"}},"ValidatedFunction":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.decorator.ValidatedFunction","name":"ValidatedFunction","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.decorator.ValidatedFunction","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.decorator","mro":["pydantic.v1.decorator.ValidatedFunction","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","function","config"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.decorator.ValidatedFunction.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","function","config"],"arg_types":["pydantic.v1.decorator.ValidatedFunction",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.decorator.AnyCallableT","id":-1,"name":"AnyCallableT","namespace":"pydantic.v1.decorator.ValidatedFunction.__init__","upper_bound":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"values":[],"variance":0},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.decorator.ConfigType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of ValidatedFunction","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.decorator.AnyCallableT","id":-1,"name":"AnyCallableT","namespace":"pydantic.v1.decorator.ValidatedFunction.__init__","upper_bound":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"values":[],"variance":0}]}}},"arg_mapping":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic.v1.decorator.ValidatedFunction.arg_mapping","name":"arg_mapping","setter_type":null,"type":{".class":"Instance","args":["builtins.int","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"build_values":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.decorator.ValidatedFunction.build_values","name":"build_values","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","args","kwargs"],"arg_types":["pydantic.v1.decorator.ValidatedFunction",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"build_values of ValidatedFunction","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"call":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.decorator.ValidatedFunction.call","name":"call","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"arg_types":["pydantic.v1.decorator.ValidatedFunction",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"call of ValidatedFunction","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"create_model":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0],"arg_names":["self","fields","takes_args","takes_kwargs","config"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.decorator.ValidatedFunction.create_model","name":"create_model","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":["self","fields","takes_args","takes_kwargs","config"],"arg_types":["pydantic.v1.decorator.ValidatedFunction",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.bool","builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.decorator.ConfigType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"create_model of ValidatedFunction","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"execute":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","m"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.decorator.ValidatedFunction.execute","name":"execute","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","m"],"arg_types":["pydantic.v1.decorator.ValidatedFunction","pydantic.v1.main.BaseModel"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"execute of ValidatedFunction","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"init_model_instance":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.decorator.ValidatedFunction.init_model_instance","name":"init_model_instance","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"arg_types":["pydantic.v1.decorator.ValidatedFunction",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"init_model_instance of ValidatedFunction","ret_type":"pydantic.v1.main.BaseModel","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"model":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.decorator.ValidatedFunction.model","name":"model","setter_type":null,"type":{".class":"TypeType","item":"pydantic.v1.decorator.DecoratorBaseModel@226"}}},"positional_only_args":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.decorator.ValidatedFunction.positional_only_args","name":"positional_only_args","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"raw_function":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.decorator.ValidatedFunction.raw_function","name":"raw_function","setter_type":null,"type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.decorator.AnyCallableT","id":-1,"name":"AnyCallableT","namespace":"pydantic.v1.decorator.ValidatedFunction.__init__","upper_bound":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"values":[],"variance":0}}},"v_args_name":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.decorator.ValidatedFunction.v_args_name","name":"v_args_name","setter_type":null,"type":"builtins.str"}},"v_kwargs_name":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.decorator.ValidatedFunction.v_kwargs_name","name":"v_kwargs_name","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.decorator.ValidatedFunction.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.decorator.ValidatedFunction","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.decorator.__all__","name":"__all__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.decorator.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.decorator.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.decorator.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.decorator.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.decorator.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.decorator.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"create_model":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.main.create_model","kind":"Gdef","module_public":false},"get_all_type_hints":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.get_all_type_hints","kind":"Gdef","module_public":false},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_public":false},"to_camel":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.to_camel","kind":"Gdef","module_public":false},"validate_arguments":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"pydantic.v1.decorator.validate_arguments","impl":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1,5],"arg_names":["func","config"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload"],"fullname":"pydantic.v1.decorator.validate_arguments","name":"validate_arguments","original_first_arg":"func","type":{".class":"CallableType","arg_kinds":[1,5],"arg_names":["func","config"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.decorator.AnyCallableT","id":-1,"name":"AnyCallableT","namespace":"pydantic.v1.decorator.validate_arguments","upper_bound":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"values":[],"variance":0},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.decorator.ConfigType"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate_arguments","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.decorator.AnyCallableT","id":-1,"name":"AnyCallableT","namespace":"pydantic.v1.decorator.validate_arguments","upper_bound":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"values":[],"variance":0}]}},"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1,5],"arg_names":["func","config"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"pydantic.v1.decorator.validate_arguments","name":"validate_arguments","original_first_arg":"func","type":{".class":"CallableType","arg_kinds":[1,5],"arg_names":["func","config"],"arg_types":[{".class":"NoneType"},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.decorator.ConfigType"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate_arguments","ret_type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.decorator.AnyCallableT","id":-1,"name":"AnyCallableT","namespace":"","upper_bound":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.decorator.AnyCallableT","id":-1,"name":"AnyCallableT","namespace":"","upper_bound":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.decorator.AnyCallableT","id":-1,"name":"AnyCallableT","namespace":"","upper_bound":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"values":[],"variance":0}]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.decorator.validate_arguments","name":"validate_arguments","setter_type":null,"type":{".class":"CallableType","arg_kinds":[1,5],"arg_names":["func","config"],"arg_types":[{".class":"NoneType"},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.decorator.ConfigType"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate_arguments","ret_type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.decorator.AnyCallableT","id":-1,"name":"AnyCallableT","namespace":"","upper_bound":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.decorator.AnyCallableT","id":-1,"name":"AnyCallableT","namespace":"","upper_bound":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.decorator.AnyCallableT","id":-1,"name":"AnyCallableT","namespace":"","upper_bound":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"values":[],"variance":0}]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["func"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"pydantic.v1.decorator.validate_arguments","name":"validate_arguments","original_first_arg":"func","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["func"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.decorator.AnyCallableT","id":-1,"name":"AnyCallableT","namespace":"pydantic.v1.decorator.validate_arguments#1","upper_bound":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate_arguments","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.decorator.AnyCallableT","id":-1,"name":"AnyCallableT","namespace":"pydantic.v1.decorator.validate_arguments#1","upper_bound":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.decorator.AnyCallableT","id":-1,"name":"AnyCallableT","namespace":"pydantic.v1.decorator.validate_arguments#1","upper_bound":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.decorator.validate_arguments","name":"validate_arguments","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["func"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.decorator.AnyCallableT","id":-1,"name":"AnyCallableT","namespace":"pydantic.v1.decorator.validate_arguments#1","upper_bound":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate_arguments","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.decorator.AnyCallableT","id":-1,"name":"AnyCallableT","namespace":"pydantic.v1.decorator.validate_arguments#1","upper_bound":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.decorator.AnyCallableT","id":-1,"name":"AnyCallableT","namespace":"pydantic.v1.decorator.validate_arguments#1","upper_bound":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[1,5],"arg_names":["func","config"],"arg_types":[{".class":"NoneType"},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.decorator.ConfigType"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate_arguments","ret_type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.decorator.AnyCallableT","id":-1,"name":"AnyCallableT","namespace":"","upper_bound":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.decorator.AnyCallableT","id":-1,"name":"AnyCallableT","namespace":"","upper_bound":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.decorator.AnyCallableT","id":-1,"name":"AnyCallableT","namespace":"","upper_bound":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"values":[],"variance":0}]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0],"arg_names":["func"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.decorator.AnyCallableT","id":-1,"name":"AnyCallableT","namespace":"pydantic.v1.decorator.validate_arguments#1","upper_bound":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate_arguments","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.decorator.AnyCallableT","id":-1,"name":"AnyCallableT","namespace":"pydantic.v1.decorator.validate_arguments#1","upper_bound":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.decorator.AnyCallableT","id":-1,"name":"AnyCallableT","namespace":"pydantic.v1.decorator.validate_arguments#1","upper_bound":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"values":[],"variance":0}]}]}}},"validator":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.class_validators.validator","kind":"Gdef","module_public":false},"wraps":{".class":"SymbolTableNode","cross_ref":"functools.wraps","kind":"Gdef","module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/decorator.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/decorator.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/decorator.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..649c0888dfc21f5f03dd967cc6e114a6e1df5282 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/decorator.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[5,6,7,8,9,4,1,2,62,1,1,1,1,1,1,1,1],"dep_prios":[5,5,5,5,5,5,5,5,20,5,30,30,30,30,30,30,30],"dependencies":["pydantic.v1.config","pydantic.v1.errors","pydantic.v1.main","pydantic.v1.typing","pydantic.v1.utils","pydantic.v1","functools","typing","inspect","builtins","_frozen_importlib","_typeshed","abc","enum","pydantic.v1.class_validators","types","typing_extensions"],"hash":"4dfef47d26f48e39812a607c878f47471e037aab","id":"pydantic.v1.decorator","ignore_all":true,"interface_hash":"0225d5e15b511d7088477bddac7e442353562853","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/decorator.py","plugin_data":null,"size":10339,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/env_settings.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/env_settings.data.json new file mode 100644 index 0000000000000000000000000000000000000000..18cb3a68af7b15390e9d3f26e173fb8c356cb368 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/env_settings.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic.v1.env_settings","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","AbstractSet":{".class":"SymbolTableNode","cross_ref":"typing.AbstractSet","kind":"Gdef"},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseConfig":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.config.BaseConfig","kind":"Gdef"},"BaseModel":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.main.BaseModel","kind":"Gdef"},"BaseSettings":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.main.BaseModel"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.env_settings.BaseSettings","name":"BaseSettings","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.env_settings.BaseSettings","has_param_spec_type":false,"metaclass_type":"pydantic.v1.main.ModelMetaclass","metadata":{"dataclass":{"attributes":[],"frozen":false},"dataclass_tag":{}},"module_name":"pydantic.v1.env_settings","mro":["pydantic.v1.env_settings.BaseSettings","pydantic.v1.main.BaseModel","pydantic.v1.utils.Representation","builtins.object"],"names":{".class":"SymbolTable","Config":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.config.BaseConfig"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.env_settings.BaseSettings.Config","name":"Config","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.env_settings.BaseSettings.Config","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.env_settings","mro":["pydantic.v1.env_settings.BaseSettings.Config","pydantic.v1.config.BaseConfig","builtins.object"],"names":{".class":"SymbolTable","arbitrary_types_allowed":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.env_settings.BaseSettings.Config.arbitrary_types_allowed","name":"arbitrary_types_allowed","setter_type":null,"type":"builtins.bool"}},"case_sensitive":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.env_settings.BaseSettings.Config.case_sensitive","name":"case_sensitive","setter_type":null,"type":"builtins.bool"}},"customise_sources":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["cls","init_settings","env_settings","file_secret_settings"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.env_settings.BaseSettings.Config.customise_sources","name":"customise_sources","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["cls","init_settings","env_settings","file_secret_settings"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.env_settings.BaseSettings.Config"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.env_settings.SettingsSourceCallable"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.env_settings.SettingsSourceCallable"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.env_settings.SettingsSourceCallable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"customise_sources of Config","ret_type":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.env_settings.SettingsSourceCallable"}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.env_settings.BaseSettings.Config.customise_sources","name":"customise_sources","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["cls","init_settings","env_settings","file_secret_settings"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.env_settings.BaseSettings.Config"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.env_settings.SettingsSourceCallable"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.env_settings.SettingsSourceCallable"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.env_settings.SettingsSourceCallable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"customise_sources of Config","ret_type":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.env_settings.SettingsSourceCallable"}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"env_file":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.env_settings.BaseSettings.Config.env_file","name":"env_file","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.env_settings.DotenvType"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"env_file_encoding":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.env_settings.BaseSettings.Config.env_file_encoding","name":"env_file_encoding","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"env_nested_delimiter":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.env_settings.BaseSettings.Config.env_nested_delimiter","name":"env_nested_delimiter","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"env_prefix":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.env_settings.BaseSettings.Config.env_prefix","name":"env_prefix","setter_type":null,"type":"builtins.str"}},"extra":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.env_settings.BaseSettings.Config.extra","name":"extra","setter_type":null,"type":"pydantic.v1.config.Extra"}},"parse_env_var":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["cls","field_name","raw_val"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.env_settings.BaseSettings.Config.parse_env_var","name":"parse_env_var","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["cls","field_name","raw_val"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.env_settings.BaseSettings.Config"},"builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parse_env_var of Config","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.env_settings.BaseSettings.Config.parse_env_var","name":"parse_env_var","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["cls","field_name","raw_val"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.env_settings.BaseSettings.Config"},"builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parse_env_var of Config","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"prepare_field":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","field"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.env_settings.BaseSettings.Config.prepare_field","name":"prepare_field","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.env_settings.BaseSettings.Config"},"pydantic.v1.fields.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prepare_field of Config","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.env_settings.BaseSettings.Config.prepare_field","name":"prepare_field","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.env_settings.BaseSettings.Config"},"pydantic.v1.fields.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prepare_field of Config","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"secrets_dir":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.env_settings.BaseSettings.Config.secrets_dir","name":"secrets_dir","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.StrPath"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"validate_all":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.env_settings.BaseSettings.Config.validate_all","name":"validate_all","setter_type":null,"type":"builtins.bool"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.env_settings.BaseSettings.Config.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.env_settings.BaseSettings.Config","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__config__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready"],"fullname":"pydantic.v1.env_settings.BaseSettings.__config__","name":"__config__","setter_type":null,"type":{".class":"TypeType","item":"pydantic.v1.env_settings.BaseSettings.Config"}}},"__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"pydantic.v1.env_settings.BaseSettings.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,4],"arg_names":["__pydantic_self__","_env_file","_env_file_encoding","_env_nested_delimiter","_secrets_dir","values"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.env_settings.BaseSettings.__init__","name":"__init__","original_first_arg":"__pydantic_self__","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,4],"arg_names":["__pydantic_self__","_env_file","_env_file_encoding","_env_nested_delimiter","_secrets_dir","values"],"arg_types":["pydantic.v1.env_settings.BaseSettings",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.env_settings.DotenvType"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.StrPath"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of BaseSettings","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"pydantic.v1.env_settings.BaseSettings.__mypy-replace","name":"__mypy-replace","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of BaseSettings","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"pydantic.v1.env_settings.BaseSettings.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of BaseSettings","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"_build_values":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1],"arg_names":["self","init_kwargs","_env_file","_env_file_encoding","_env_nested_delimiter","_secrets_dir"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.env_settings.BaseSettings._build_values","name":"_build_values","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["self","init_kwargs","_env_file","_env_file_encoding","_env_nested_delimiter","_secrets_dir"],"arg_types":["pydantic.v1.env_settings.BaseSettings",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.env_settings.DotenvType"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.StrPath"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_build_values of BaseSettings","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.env_settings.BaseSettings.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.env_settings.BaseSettings","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"ClassVar":{".class":"SymbolTableNode","cross_ref":"typing.ClassVar","kind":"Gdef"},"Dict":{".class":"SymbolTableNode","cross_ref":"typing.Dict","kind":"Gdef"},"DotenvType":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic.v1.env_settings.DotenvType","line":16,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.StrPath"},{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.StrPath"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.StrPath"}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":false}}},"EnvSettingsSource":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.env_settings.EnvSettingsSource","name":"EnvSettingsSource","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.env_settings.EnvSettingsSource","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.env_settings","mro":["pydantic.v1.env_settings.EnvSettingsSource","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","settings"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.env_settings.EnvSettingsSource.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","settings"],"arg_types":["pydantic.v1.env_settings.EnvSettingsSource","pydantic.v1.env_settings.BaseSettings"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of EnvSettingsSource","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1],"arg_names":["self","env_file","env_file_encoding","env_nested_delimiter","env_prefix_len"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.env_settings.EnvSettingsSource.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1],"arg_names":["self","env_file","env_file_encoding","env_nested_delimiter","env_prefix_len"],"arg_types":["pydantic.v1.env_settings.EnvSettingsSource",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.env_settings.DotenvType"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of EnvSettingsSource","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.env_settings.EnvSettingsSource.__repr__","name":"__repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["pydantic.v1.env_settings.EnvSettingsSource"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr__ of EnvSettingsSource","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic.v1.env_settings.EnvSettingsSource.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_read_env_files":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","case_sensitive"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.env_settings.EnvSettingsSource._read_env_files","name":"_read_env_files","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","case_sensitive"],"arg_types":["pydantic.v1.env_settings.EnvSettingsSource","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_read_env_files of EnvSettingsSource","ret_type":{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"env_file":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic.v1.env_settings.EnvSettingsSource.env_file","name":"env_file","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.env_settings.DotenvType"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"env_file_encoding":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic.v1.env_settings.EnvSettingsSource.env_file_encoding","name":"env_file_encoding","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"env_nested_delimiter":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic.v1.env_settings.EnvSettingsSource.env_nested_delimiter","name":"env_nested_delimiter","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"env_prefix_len":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic.v1.env_settings.EnvSettingsSource.env_prefix_len","name":"env_prefix_len","setter_type":null,"type":"builtins.int"}},"explode_env_vars":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","field","env_vars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.env_settings.EnvSettingsSource.explode_env_vars","name":"explode_env_vars","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","field","env_vars"],"arg_types":["pydantic.v1.env_settings.EnvSettingsSource","pydantic.v1.fields.ModelField",{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"typing.Mapping"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"explode_env_vars of EnvSettingsSource","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"field_is_complex":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","field"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.env_settings.EnvSettingsSource.field_is_complex","name":"field_is_complex","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","field"],"arg_types":["pydantic.v1.env_settings.EnvSettingsSource","pydantic.v1.fields.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"field_is_complex of EnvSettingsSource","ret_type":{".class":"TupleType","implicit":false,"items":["builtins.bool","builtins.bool"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.env_settings.EnvSettingsSource.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.env_settings.EnvSettingsSource","values":[],"variance":0},"slots":["env_file","env_file_encoding","env_nested_delimiter","env_prefix_len"],"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Extra":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.config.Extra","kind":"Gdef"},"InitSettingsSource":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.env_settings.InitSettingsSource","name":"InitSettingsSource","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.env_settings.InitSettingsSource","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.env_settings","mro":["pydantic.v1.env_settings.InitSettingsSource","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","settings"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.env_settings.InitSettingsSource.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","settings"],"arg_types":["pydantic.v1.env_settings.InitSettingsSource","pydantic.v1.env_settings.BaseSettings"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of InitSettingsSource","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","init_kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.env_settings.InitSettingsSource.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","init_kwargs"],"arg_types":["pydantic.v1.env_settings.InitSettingsSource",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of InitSettingsSource","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.env_settings.InitSettingsSource.__repr__","name":"__repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["pydantic.v1.env_settings.InitSettingsSource"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr__ of InitSettingsSource","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic.v1.env_settings.InitSettingsSource.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"init_kwargs":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.env_settings.InitSettingsSource.init_kwargs","name":"init_kwargs","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.env_settings.InitSettingsSource.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.env_settings.InitSettingsSource","values":[],"variance":0},"slots":["init_kwargs"],"tuple_type":null,"type_vars":[],"typeddict_type":null}},"JsonWrapper":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.JsonWrapper","kind":"Gdef"},"List":{".class":"SymbolTableNode","cross_ref":"typing.List","kind":"Gdef"},"Mapping":{".class":"SymbolTableNode","cross_ref":"typing.Mapping","kind":"Gdef"},"ModelField":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.fields.ModelField","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"Path":{".class":"SymbolTableNode","cross_ref":"pathlib.Path","kind":"Gdef"},"SecretsSettingsSource":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.env_settings.SecretsSettingsSource","name":"SecretsSettingsSource","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.env_settings.SecretsSettingsSource","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.env_settings","mro":["pydantic.v1.env_settings.SecretsSettingsSource","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","settings"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.env_settings.SecretsSettingsSource.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","settings"],"arg_types":["pydantic.v1.env_settings.SecretsSettingsSource","pydantic.v1.env_settings.BaseSettings"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of SecretsSettingsSource","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","secrets_dir"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.env_settings.SecretsSettingsSource.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","secrets_dir"],"arg_types":["pydantic.v1.env_settings.SecretsSettingsSource",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.StrPath"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of SecretsSettingsSource","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.env_settings.SecretsSettingsSource.__repr__","name":"__repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["pydantic.v1.env_settings.SecretsSettingsSource"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr__ of SecretsSettingsSource","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic.v1.env_settings.SecretsSettingsSource.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"secrets_dir":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic.v1.env_settings.SecretsSettingsSource.secrets_dir","name":"secrets_dir","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.StrPath"},{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.env_settings.SecretsSettingsSource.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.env_settings.SecretsSettingsSource","values":[],"variance":0},"slots":["secrets_dir"],"tuple_type":null,"type_vars":[],"typeddict_type":null}},"SettingsError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.ValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.env_settings.SettingsError","name":"SettingsError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.env_settings.SettingsError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.env_settings","mro":["pydantic.v1.env_settings.SettingsError","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.env_settings.SettingsError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.env_settings.SettingsError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"SettingsSourceCallable":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic.v1.env_settings.SettingsSourceCallable","line":15,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["pydantic.v1.env_settings.BaseSettings"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"StrPath":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.StrPath","kind":"Gdef"},"Tuple":{".class":"SymbolTableNode","cross_ref":"typing.Tuple","kind":"Gdef"},"Type":{".class":"SymbolTableNode","cross_ref":"typing.Type","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.env_settings.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.env_settings.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.env_settings.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.env_settings.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.env_settings.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.env_settings.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"deep_update":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.deep_update","kind":"Gdef"},"display_as_type":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.display_as_type","kind":"Gdef"},"env_file_sentinel":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.env_settings.env_file_sentinel","name":"env_file_sentinel","setter_type":null,"type":"builtins.str"}},"find_case_path":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["dir_path","file_name","case_sensitive"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.env_settings.find_case_path","name":"find_case_path","original_first_arg":"dir_path","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["dir_path","file_name","case_sensitive"],"arg_types":["pathlib.Path","builtins.str","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"find_case_path","ret_type":{".class":"UnionType","items":["pathlib.Path",{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_origin":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.get_origin","kind":"Gdef"},"is_union":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.is_union","kind":"Gdef"},"lenient_issubclass":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.lenient_issubclass","kind":"Gdef"},"os":{".class":"SymbolTableNode","cross_ref":"os","kind":"Gdef"},"path_type":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.path_type","kind":"Gdef"},"read_env_file":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5],"arg_names":["file_path","encoding","case_sensitive"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.env_settings.read_env_file","name":"read_env_file","original_first_arg":"file_path","type":{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":["file_path","encoding","case_sensitive"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.StrPath"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"read_env_file","ret_type":{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"sequence_like":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.sequence_like","kind":"Gdef"},"warnings":{".class":"SymbolTableNode","cross_ref":"warnings","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/env_settings.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/env_settings.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/env_settings.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..5c514483e06b01ad54c559be02102e7a92075f68 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/env_settings.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[6,7,8,9,10,11,1,2,3,4,1,1,1,1,1],"dep_prios":[5,5,5,5,5,5,10,10,5,5,5,30,30,30,30],"dependencies":["pydantic.v1.config","pydantic.v1.fields","pydantic.v1.main","pydantic.v1.types","pydantic.v1.typing","pydantic.v1.utils","os","warnings","pathlib","typing","builtins","_frozen_importlib","abc","enum","typing_extensions"],"hash":"57945b11348a6253aae0421eed6edf464655452e","id":"pydantic.v1.env_settings","ignore_all":true,"interface_hash":"af64222f912ab798d694ce68d264a3ad8a4b9441","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/env_settings.py","plugin_data":null,"size":14105,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/error_wrappers.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/error_wrappers.data.json new file mode 100644 index 0000000000000000000000000000000000000000..2b02e15b7a51aa9c4f99125dbd1f0509d84f213a --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/error_wrappers.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic.v1.error_wrappers","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_public":false},"BaseConfig":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.config.BaseConfig","kind":"Gdef","module_public":false},"Dict":{".class":"SymbolTableNode","cross_ref":"typing.Dict","kind":"Gdef","module_public":false},"ErrorDict":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.error_wrappers.ErrorDict","name":"ErrorDict","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.error_wrappers.ErrorDict","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.error_wrappers","mro":["pydantic.v1.error_wrappers.ErrorDict","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["loc",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.error_wrappers.Loc"}],["msg","builtins.str"],["type","builtins.str"],["ctx",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}]],"readonly_keys":[],"required_keys":["loc","msg","type"]}}},"ErrorList":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic.v1.error_wrappers.ErrorList","line":47,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Sequence"},"pydantic.v1.error_wrappers.ErrorWrapper"],"uses_pep604_syntax":false}}},"ErrorWrapper":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.utils.Representation"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.error_wrappers.ErrorWrapper","name":"ErrorWrapper","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.error_wrappers.ErrorWrapper","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.error_wrappers","mro":["pydantic.v1.error_wrappers.ErrorWrapper","pydantic.v1.utils.Representation","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","exc","loc"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.error_wrappers.ErrorWrapper.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","exc","loc"],"arg_types":["pydantic.v1.error_wrappers.ErrorWrapper","builtins.Exception",{".class":"UnionType","items":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.error_wrappers.Loc"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of ErrorWrapper","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr_args__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.error_wrappers.ErrorWrapper.__repr_args__","name":"__repr_args__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.error_wrappers.ErrorWrapper"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr_args__ of ErrorWrapper","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.ReprArgs"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic.v1.error_wrappers.ErrorWrapper.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_loc":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.error_wrappers.ErrorWrapper._loc","name":"_loc","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.error_wrappers.Loc"}],"uses_pep604_syntax":false}}},"exc":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.error_wrappers.ErrorWrapper.exc","name":"exc","setter_type":null,"type":"builtins.Exception"}},"loc_tuple":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.error_wrappers.ErrorWrapper.loc_tuple","name":"loc_tuple","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.error_wrappers.ErrorWrapper"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"loc_tuple of ErrorWrapper","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.error_wrappers.Loc"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.error_wrappers.ErrorWrapper.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.error_wrappers.ErrorWrapper","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Generator":{".class":"SymbolTableNode","cross_ref":"typing.Generator","kind":"Gdef","module_public":false},"List":{".class":"SymbolTableNode","cross_ref":"typing.List","kind":"Gdef","module_public":false},"Loc":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.error_wrappers.Loc","line":14,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}}},"ModelOrDc":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.ModelOrDc","kind":"Gdef","module_public":false},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef","module_public":false},"ReprArgs":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.ReprArgs","kind":"Gdef","module_public":false},"Representation":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.Representation","kind":"Gdef","module_public":false},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef","module_public":false},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef","module_public":false},"Tuple":{".class":"SymbolTableNode","cross_ref":"typing.Tuple","kind":"Gdef","module_public":false},"Type":{".class":"SymbolTableNode","cross_ref":"typing.Type","kind":"Gdef","module_public":false},"TypedDict":{".class":"SymbolTableNode","cross_ref":"typing.TypedDict","kind":"Gdef","module_public":false},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef","module_public":false},"ValidationError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.utils.Representation","builtins.ValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.error_wrappers.ValidationError","name":"ValidationError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.error_wrappers.ValidationError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.error_wrappers","mro":["pydantic.v1.error_wrappers.ValidationError","pydantic.v1.utils.Representation","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","errors","model"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.error_wrappers.ValidationError.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","errors","model"],"arg_types":["pydantic.v1.error_wrappers.ValidationError",{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.error_wrappers.ErrorList"}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.ModelOrDc"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of ValidationError","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr_args__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.error_wrappers.ValidationError.__repr_args__","name":"__repr_args__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.error_wrappers.ValidationError"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr_args__ of ValidationError","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.ReprArgs"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic.v1.error_wrappers.ValidationError.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"__str__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.error_wrappers.ValidationError.__str__","name":"__str__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["pydantic.v1.error_wrappers.ValidationError"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__str__ of ValidationError","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_error_cache":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic.v1.error_wrappers.ValidationError._error_cache","name":"_error_cache","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.error_wrappers.ErrorDict"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"errors":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.error_wrappers.ValidationError.errors","name":"errors","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.error_wrappers.ValidationError"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"errors of ValidationError","ret_type":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.error_wrappers.ErrorDict"}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"json":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5],"arg_names":["self","indent"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.error_wrappers.ValidationError.json","name":"json","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5],"arg_names":["self","indent"],"arg_types":["pydantic.v1.error_wrappers.ValidationError",{".class":"UnionType","items":[{".class":"NoneType"},"builtins.int","builtins.str"],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"json of ValidationError","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"model":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.error_wrappers.ValidationError.model","name":"model","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.ModelOrDc"}}},"raw_errors":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.error_wrappers.ValidationError.raw_errors","name":"raw_errors","setter_type":null,"type":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.error_wrappers.ErrorList"}],"extra_attrs":null,"type_ref":"typing.Sequence"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.error_wrappers.ValidationError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.error_wrappers.ValidationError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_EXC_TYPE_CACHE":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic.v1.error_wrappers._EXC_TYPE_CACHE","name":"_EXC_TYPE_CACHE","setter_type":null,"type":{".class":"Instance","args":[{".class":"TypeType","item":"builtins.Exception"},"builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_ErrorDictRequired":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.error_wrappers._ErrorDictRequired","name":"_ErrorDictRequired","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.error_wrappers._ErrorDictRequired","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.error_wrappers","mro":["pydantic.v1.error_wrappers._ErrorDictRequired","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["loc",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.error_wrappers.Loc"}],["msg","builtins.str"],["type","builtins.str"]],"readonly_keys":[],"required_keys":["loc","msg","type"]}}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.error_wrappers.__all__","name":"__all__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.error_wrappers.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.error_wrappers.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.error_wrappers.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.error_wrappers.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.error_wrappers.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.error_wrappers.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_display_error_loc":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["error"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.error_wrappers._display_error_loc","name":"_display_error_loc","original_first_arg":"error","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["error"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.error_wrappers.ErrorDict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_display_error_loc","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_display_error_type_and_ctx":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["error"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.error_wrappers._display_error_type_and_ctx","name":"_display_error_type_and_ctx","original_first_arg":"error","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["error"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.error_wrappers.ErrorDict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_display_error_type_and_ctx","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_get_exc_type":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.error_wrappers._get_exc_type","name":"_get_exc_type","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"builtins.Exception"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_exc_type","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"display_errors":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["errors"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.error_wrappers.display_errors","name":"display_errors","original_first_arg":"errors","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["errors"],"arg_types":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.error_wrappers.ErrorDict"}],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"display_errors","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"error_dict":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["exc","config","loc"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.error_wrappers.error_dict","name":"error_dict","original_first_arg":"exc","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["exc","config","loc"],"arg_types":["builtins.Exception",{".class":"TypeType","item":"pydantic.v1.config.BaseConfig"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.error_wrappers.Loc"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"error_dict","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.error_wrappers.ErrorDict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"flatten_errors":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["errors","config","loc"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.error_wrappers.flatten_errors","name":"flatten_errors","original_first_arg":"errors","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["errors","config","loc"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"TypeType","item":"pydantic.v1.config.BaseConfig"},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.error_wrappers.Loc"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"flatten_errors","ret_type":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.error_wrappers.ErrorDict"},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Generator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_exc_type":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.error_wrappers.get_exc_type","name":"get_exc_type","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"builtins.Exception"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_exc_type","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"json":{".class":"SymbolTableNode","cross_ref":"json","kind":"Gdef","module_public":false},"pydantic_encoder":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.json.pydantic_encoder","kind":"Gdef","module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/error_wrappers.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/error_wrappers.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/error_wrappers.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..31bbe31ca8c4d62ec0ff113e2230e7d486939100 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/error_wrappers.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[4,5,10,11,12,1,2,8,1,1,1,1,1],"dep_prios":[5,5,25,25,25,10,5,25,5,30,30,30,30],"dependencies":["pydantic.v1.json","pydantic.v1.utils","pydantic.v1.config","pydantic.v1.types","pydantic.v1.typing","json","typing","typing_extensions","builtins","_frozen_importlib","abc","pydantic.v1.dataclasses","pydantic.v1.main"],"hash":"5ba402b9ba6723626e62ccb4a225b352e9b91602","id":"pydantic.v1.error_wrappers","ignore_all":true,"interface_hash":"6d2c93b3e051c5544000693c99af512865d4383d","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/error_wrappers.py","plugin_data":null,"size":5196,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/errors.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/errors.data.json new file mode 100644 index 0000000000000000000000000000000000000000..19ef35b40489fe23fab984726f4f1bfc5e2a1125 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/errors.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic.v1.errors","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_public":false},"AnyStrMaxLengthError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.AnyStrMaxLengthError","name":"AnyStrMaxLengthError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.AnyStrMaxLengthError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.AnyStrMaxLengthError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3],"arg_names":["self","limit_value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.errors.AnyStrMaxLengthError.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3],"arg_names":["self","limit_value"],"arg_types":["pydantic.v1.errors.AnyStrMaxLengthError","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of AnyStrMaxLengthError","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.AnyStrMaxLengthError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.AnyStrMaxLengthError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.AnyStrMaxLengthError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.AnyStrMaxLengthError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"AnyStrMinLengthError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.AnyStrMinLengthError","name":"AnyStrMinLengthError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.AnyStrMinLengthError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.AnyStrMinLengthError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3],"arg_names":["self","limit_value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.errors.AnyStrMinLengthError.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3],"arg_names":["self","limit_value"],"arg_types":["pydantic.v1.errors.AnyStrMinLengthError","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of AnyStrMinLengthError","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.AnyStrMinLengthError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.AnyStrMinLengthError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.AnyStrMinLengthError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.AnyStrMinLengthError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ArbitraryTypeError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticTypeError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.ArbitraryTypeError","name":"ArbitraryTypeError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.ArbitraryTypeError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.ArbitraryTypeError","pydantic.v1.errors.PydanticTypeError","pydantic.v1.errors.PydanticErrorMixin","builtins.TypeError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3],"arg_names":["self","expected_arbitrary_type"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.errors.ArbitraryTypeError.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3],"arg_names":["self","expected_arbitrary_type"],"arg_types":["pydantic.v1.errors.ArbitraryTypeError",{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of ArbitraryTypeError","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.ArbitraryTypeError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.ArbitraryTypeError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.ArbitraryTypeError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.ArbitraryTypeError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"BoolError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticTypeError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.BoolError","name":"BoolError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.BoolError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.BoolError","pydantic.v1.errors.PydanticTypeError","pydantic.v1.errors.PydanticErrorMixin","builtins.TypeError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.BoolError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.BoolError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.BoolError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"BytesError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticTypeError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.BytesError","name":"BytesError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.BytesError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.BytesError","pydantic.v1.errors.PydanticTypeError","pydantic.v1.errors.PydanticErrorMixin","builtins.TypeError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.BytesError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.BytesError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.BytesError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef","module_public":false},"CallableError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticTypeError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.CallableError","name":"CallableError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.CallableError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.CallableError","pydantic.v1.errors.PydanticTypeError","pydantic.v1.errors.PydanticErrorMixin","builtins.TypeError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.CallableError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.CallableError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.CallableError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ClassError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticTypeError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.ClassError","name":"ClassError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.ClassError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.ClassError","pydantic.v1.errors.PydanticTypeError","pydantic.v1.errors.PydanticErrorMixin","builtins.TypeError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.ClassError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.ClassError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.ClassError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.ClassError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ColorError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.ColorError","name":"ColorError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.ColorError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.ColorError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.ColorError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.ColorError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.ColorError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ConfigError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.RuntimeError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.ConfigError","name":"ConfigError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.ConfigError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.ConfigError","builtins.RuntimeError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.ConfigError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.ConfigError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"DataclassTypeError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticTypeError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.DataclassTypeError","name":"DataclassTypeError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.DataclassTypeError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.DataclassTypeError","pydantic.v1.errors.PydanticTypeError","pydantic.v1.errors.PydanticErrorMixin","builtins.TypeError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.DataclassTypeError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.DataclassTypeError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.DataclassTypeError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.DataclassTypeError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"DateError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.DateError","name":"DateError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.DateError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.DateError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.DateError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.DateError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.DateError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"DateNotInTheFutureError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.DateNotInTheFutureError","name":"DateNotInTheFutureError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.DateNotInTheFutureError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.DateNotInTheFutureError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.DateNotInTheFutureError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.DateNotInTheFutureError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.DateNotInTheFutureError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.DateNotInTheFutureError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"DateNotInThePastError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.DateNotInThePastError","name":"DateNotInThePastError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.DateNotInThePastError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.DateNotInThePastError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.DateNotInThePastError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.DateNotInThePastError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.DateNotInThePastError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.DateNotInThePastError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"DateTimeError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.DateTimeError","name":"DateTimeError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.DateTimeError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.DateTimeError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.DateTimeError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.DateTimeError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.DateTimeError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Decimal":{".class":"SymbolTableNode","cross_ref":"decimal.Decimal","kind":"Gdef","module_public":false},"DecimalError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticTypeError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.DecimalError","name":"DecimalError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.DecimalError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.DecimalError","pydantic.v1.errors.PydanticTypeError","pydantic.v1.errors.PydanticErrorMixin","builtins.TypeError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.DecimalError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.DecimalError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.DecimalError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"DecimalIsNotFiniteError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.DecimalIsNotFiniteError","name":"DecimalIsNotFiniteError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.DecimalIsNotFiniteError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.DecimalIsNotFiniteError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.DecimalIsNotFiniteError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.DecimalIsNotFiniteError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.DecimalIsNotFiniteError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.DecimalIsNotFiniteError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"DecimalMaxDigitsError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.DecimalMaxDigitsError","name":"DecimalMaxDigitsError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.DecimalMaxDigitsError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.DecimalMaxDigitsError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3],"arg_names":["self","max_digits"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.errors.DecimalMaxDigitsError.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3],"arg_names":["self","max_digits"],"arg_types":["pydantic.v1.errors.DecimalMaxDigitsError","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of DecimalMaxDigitsError","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.DecimalMaxDigitsError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.DecimalMaxDigitsError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.DecimalMaxDigitsError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.DecimalMaxDigitsError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"DecimalMaxPlacesError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.DecimalMaxPlacesError","name":"DecimalMaxPlacesError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.DecimalMaxPlacesError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.DecimalMaxPlacesError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3],"arg_names":["self","decimal_places"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.errors.DecimalMaxPlacesError.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3],"arg_names":["self","decimal_places"],"arg_types":["pydantic.v1.errors.DecimalMaxPlacesError","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of DecimalMaxPlacesError","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.DecimalMaxPlacesError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.DecimalMaxPlacesError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.DecimalMaxPlacesError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.DecimalMaxPlacesError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"DecimalWholeDigitsError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.DecimalWholeDigitsError","name":"DecimalWholeDigitsError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.DecimalWholeDigitsError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.DecimalWholeDigitsError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3],"arg_names":["self","whole_digits"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.errors.DecimalWholeDigitsError.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3],"arg_names":["self","whole_digits"],"arg_types":["pydantic.v1.errors.DecimalWholeDigitsError","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of DecimalWholeDigitsError","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.DecimalWholeDigitsError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.DecimalWholeDigitsError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.DecimalWholeDigitsError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.DecimalWholeDigitsError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"DequeError":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticTypeError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.DequeError","name":"DequeError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.DequeError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.DequeError","pydantic.v1.errors.PydanticTypeError","pydantic.v1.errors.PydanticErrorMixin","builtins.TypeError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.DequeError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.DequeError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.DequeError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"DictError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticTypeError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.DictError","name":"DictError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.DictError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.DictError","pydantic.v1.errors.PydanticTypeError","pydantic.v1.errors.PydanticErrorMixin","builtins.TypeError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.DictError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.DictError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.DictError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"DictStrAny":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.DictStrAny","kind":"Gdef","module_public":false},"DurationError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.DurationError","name":"DurationError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.DurationError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.DurationError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.DurationError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.DurationError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.DurationError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"EmailError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.EmailError","name":"EmailError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.EmailError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.EmailError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.EmailError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.EmailError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.EmailError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"EnumError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticTypeError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.EnumError","name":"EnumError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.EnumError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.EnumError","pydantic.v1.errors.PydanticTypeError","pydantic.v1.errors.PydanticErrorMixin","builtins.TypeError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.EnumError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.EnumError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.EnumError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.EnumError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"EnumMemberError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticTypeError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.EnumMemberError","name":"EnumMemberError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.EnumMemberError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.EnumMemberError","pydantic.v1.errors.PydanticTypeError","pydantic.v1.errors.PydanticErrorMixin","builtins.TypeError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","__str__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.errors.EnumMemberError.__str__","name":"__str__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["pydantic.v1.errors.EnumMemberError"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__str__ of EnumMemberError","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.EnumMemberError.code","name":"code","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.EnumMemberError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.EnumMemberError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ExtraError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.ExtraError","name":"ExtraError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.ExtraError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.ExtraError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.ExtraError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.ExtraError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.ExtraError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"FloatError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticTypeError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.FloatError","name":"FloatError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.FloatError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.FloatError","pydantic.v1.errors.PydanticTypeError","pydantic.v1.errors.PydanticErrorMixin","builtins.TypeError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.FloatError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.FloatError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.FloatError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"FrozenSetError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticTypeError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.FrozenSetError","name":"FrozenSetError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.FrozenSetError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.FrozenSetError","pydantic.v1.errors.PydanticTypeError","pydantic.v1.errors.PydanticErrorMixin","builtins.TypeError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.FrozenSetError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.FrozenSetError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.FrozenSetError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"FrozenSetMaxLengthError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.FrozenSetMaxLengthError","name":"FrozenSetMaxLengthError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.FrozenSetMaxLengthError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.FrozenSetMaxLengthError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3],"arg_names":["self","limit_value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.errors.FrozenSetMaxLengthError.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3],"arg_names":["self","limit_value"],"arg_types":["pydantic.v1.errors.FrozenSetMaxLengthError","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of FrozenSetMaxLengthError","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.FrozenSetMaxLengthError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.FrozenSetMaxLengthError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.FrozenSetMaxLengthError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.FrozenSetMaxLengthError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"FrozenSetMinLengthError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.FrozenSetMinLengthError","name":"FrozenSetMinLengthError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.FrozenSetMinLengthError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.FrozenSetMinLengthError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3],"arg_names":["self","limit_value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.errors.FrozenSetMinLengthError.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3],"arg_names":["self","limit_value"],"arg_types":["pydantic.v1.errors.FrozenSetMinLengthError","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of FrozenSetMinLengthError","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.FrozenSetMinLengthError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.FrozenSetMinLengthError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.FrozenSetMinLengthError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.FrozenSetMinLengthError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"HashableError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticTypeError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.HashableError","name":"HashableError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.HashableError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.HashableError","pydantic.v1.errors.PydanticTypeError","pydantic.v1.errors.PydanticErrorMixin","builtins.TypeError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.HashableError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.HashableError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.HashableError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"IPv4AddressError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.IPv4AddressError","name":"IPv4AddressError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.IPv4AddressError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.IPv4AddressError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.IPv4AddressError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.IPv4AddressError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.IPv4AddressError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"IPv4InterfaceError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.IPv4InterfaceError","name":"IPv4InterfaceError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.IPv4InterfaceError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.IPv4InterfaceError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.IPv4InterfaceError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.IPv4InterfaceError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.IPv4InterfaceError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"IPv4NetworkError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.IPv4NetworkError","name":"IPv4NetworkError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.IPv4NetworkError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.IPv4NetworkError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.IPv4NetworkError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.IPv4NetworkError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.IPv4NetworkError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"IPv6AddressError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.IPv6AddressError","name":"IPv6AddressError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.IPv6AddressError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.IPv6AddressError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.IPv6AddressError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.IPv6AddressError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.IPv6AddressError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"IPv6InterfaceError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.IPv6InterfaceError","name":"IPv6InterfaceError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.IPv6InterfaceError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.IPv6InterfaceError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.IPv6InterfaceError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.IPv6InterfaceError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.IPv6InterfaceError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"IPv6NetworkError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.IPv6NetworkError","name":"IPv6NetworkError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.IPv6NetworkError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.IPv6NetworkError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.IPv6NetworkError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.IPv6NetworkError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.IPv6NetworkError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"IPvAnyAddressError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.IPvAnyAddressError","name":"IPvAnyAddressError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.IPvAnyAddressError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.IPvAnyAddressError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.IPvAnyAddressError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.IPvAnyAddressError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.IPvAnyAddressError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"IPvAnyInterfaceError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.IPvAnyInterfaceError","name":"IPvAnyInterfaceError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.IPvAnyInterfaceError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.IPvAnyInterfaceError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.IPvAnyInterfaceError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.IPvAnyInterfaceError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.IPvAnyInterfaceError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"IPvAnyNetworkError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.IPvAnyNetworkError","name":"IPvAnyNetworkError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.IPvAnyNetworkError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.IPvAnyNetworkError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.IPvAnyNetworkError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.IPvAnyNetworkError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.IPvAnyNetworkError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"IntEnumError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticTypeError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.IntEnumError","name":"IntEnumError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.IntEnumError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.IntEnumError","pydantic.v1.errors.PydanticTypeError","pydantic.v1.errors.PydanticErrorMixin","builtins.TypeError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.IntEnumError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.IntEnumError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.IntEnumError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.IntEnumError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"IntegerError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticTypeError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.IntegerError","name":"IntegerError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.IntegerError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.IntegerError","pydantic.v1.errors.PydanticTypeError","pydantic.v1.errors.PydanticErrorMixin","builtins.TypeError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.IntegerError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.IntegerError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.IntegerError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"InvalidByteSize":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.InvalidByteSize","name":"InvalidByteSize","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.InvalidByteSize","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.InvalidByteSize","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.InvalidByteSize.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.InvalidByteSize.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.InvalidByteSize","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"InvalidByteSizeUnit":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.InvalidByteSizeUnit","name":"InvalidByteSizeUnit","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.InvalidByteSizeUnit","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.InvalidByteSizeUnit","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.InvalidByteSizeUnit.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.InvalidByteSizeUnit.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.InvalidByteSizeUnit","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"InvalidDiscriminator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.InvalidDiscriminator","name":"InvalidDiscriminator","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.InvalidDiscriminator","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.InvalidDiscriminator","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,3,3],"arg_names":["self","discriminator_key","discriminator_value","allowed_values"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.errors.InvalidDiscriminator.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3,3,3],"arg_names":["self","discriminator_key","discriminator_value","allowed_values"],"arg_types":["pydantic.v1.errors.InvalidDiscriminator","builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of InvalidDiscriminator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.InvalidDiscriminator.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.InvalidDiscriminator.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.InvalidDiscriminator.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.InvalidDiscriminator","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"InvalidLengthForBrand":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.InvalidLengthForBrand","name":"InvalidLengthForBrand","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.InvalidLengthForBrand","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.InvalidLengthForBrand","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.InvalidLengthForBrand.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.InvalidLengthForBrand.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.InvalidLengthForBrand.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.InvalidLengthForBrand","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"IterableError":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticTypeError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.IterableError","name":"IterableError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.IterableError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.IterableError","pydantic.v1.errors.PydanticTypeError","pydantic.v1.errors.PydanticErrorMixin","builtins.TypeError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.IterableError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.IterableError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.IterableError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"JsonError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.JsonError","name":"JsonError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.JsonError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.JsonError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.JsonError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.JsonError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.JsonError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"JsonTypeError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticTypeError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.JsonTypeError","name":"JsonTypeError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.JsonTypeError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.JsonTypeError","pydantic.v1.errors.PydanticTypeError","pydantic.v1.errors.PydanticErrorMixin","builtins.TypeError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.JsonTypeError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.JsonTypeError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.JsonTypeError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.JsonTypeError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ListError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticTypeError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.ListError","name":"ListError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.ListError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.ListError","pydantic.v1.errors.PydanticTypeError","pydantic.v1.errors.PydanticErrorMixin","builtins.TypeError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.ListError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.ListError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.ListError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ListMaxLengthError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.ListMaxLengthError","name":"ListMaxLengthError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.ListMaxLengthError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.ListMaxLengthError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3],"arg_names":["self","limit_value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.errors.ListMaxLengthError.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3],"arg_names":["self","limit_value"],"arg_types":["pydantic.v1.errors.ListMaxLengthError","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of ListMaxLengthError","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.ListMaxLengthError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.ListMaxLengthError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.ListMaxLengthError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.ListMaxLengthError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ListMinLengthError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.ListMinLengthError","name":"ListMinLengthError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.ListMinLengthError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.ListMinLengthError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3],"arg_names":["self","limit_value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.errors.ListMinLengthError.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3],"arg_names":["self","limit_value"],"arg_types":["pydantic.v1.errors.ListMinLengthError","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of ListMinLengthError","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.ListMinLengthError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.ListMinLengthError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.ListMinLengthError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.ListMinLengthError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ListUniqueItemsError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.ListUniqueItemsError","name":"ListUniqueItemsError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.ListUniqueItemsError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.ListUniqueItemsError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.ListUniqueItemsError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.ListUniqueItemsError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.ListUniqueItemsError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.ListUniqueItemsError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"LuhnValidationError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.LuhnValidationError","name":"LuhnValidationError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.LuhnValidationError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.LuhnValidationError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.LuhnValidationError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.LuhnValidationError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.LuhnValidationError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.LuhnValidationError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"MissingDiscriminator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.MissingDiscriminator","name":"MissingDiscriminator","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.MissingDiscriminator","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.MissingDiscriminator","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.MissingDiscriminator.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.MissingDiscriminator.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.MissingDiscriminator.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.MissingDiscriminator","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"MissingError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.MissingError","name":"MissingError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.MissingError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.MissingError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.MissingError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.MissingError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.MissingError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"NoneIsAllowedError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticTypeError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.NoneIsAllowedError","name":"NoneIsAllowedError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.NoneIsAllowedError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.NoneIsAllowedError","pydantic.v1.errors.PydanticTypeError","pydantic.v1.errors.PydanticErrorMixin","builtins.TypeError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.NoneIsAllowedError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.NoneIsAllowedError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.NoneIsAllowedError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.NoneIsAllowedError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"NoneIsNotAllowedError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticTypeError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.NoneIsNotAllowedError","name":"NoneIsNotAllowedError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.NoneIsNotAllowedError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.NoneIsNotAllowedError","pydantic.v1.errors.PydanticTypeError","pydantic.v1.errors.PydanticErrorMixin","builtins.TypeError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.NoneIsNotAllowedError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.NoneIsNotAllowedError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.NoneIsNotAllowedError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.NoneIsNotAllowedError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"NotDigitError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.NotDigitError","name":"NotDigitError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.NotDigitError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.NotDigitError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.NotDigitError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.NotDigitError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.NotDigitError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.NotDigitError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"NotNoneError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticTypeError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.NotNoneError","name":"NotNoneError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.NotNoneError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.NotNoneError","pydantic.v1.errors.PydanticTypeError","pydantic.v1.errors.PydanticErrorMixin","builtins.TypeError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.NotNoneError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.NotNoneError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.NotNoneError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.NotNoneError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"NumberNotFiniteError":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.NumberNotFiniteError","name":"NumberNotFiniteError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.NumberNotFiniteError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.NumberNotFiniteError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.NumberNotFiniteError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.NumberNotFiniteError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.NumberNotFiniteError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.NumberNotFiniteError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"NumberNotGeError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors._NumberBoundError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.NumberNotGeError","name":"NumberNotGeError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.NumberNotGeError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.NumberNotGeError","pydantic.v1.errors._NumberBoundError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.NumberNotGeError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.NumberNotGeError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.NumberNotGeError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.NumberNotGeError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"NumberNotGtError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors._NumberBoundError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.NumberNotGtError","name":"NumberNotGtError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.NumberNotGtError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.NumberNotGtError","pydantic.v1.errors._NumberBoundError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.NumberNotGtError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.NumberNotGtError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.NumberNotGtError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.NumberNotGtError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"NumberNotLeError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors._NumberBoundError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.NumberNotLeError","name":"NumberNotLeError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.NumberNotLeError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.NumberNotLeError","pydantic.v1.errors._NumberBoundError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.NumberNotLeError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.NumberNotLeError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.NumberNotLeError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.NumberNotLeError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"NumberNotLtError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors._NumberBoundError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.NumberNotLtError","name":"NumberNotLtError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.NumberNotLtError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.NumberNotLtError","pydantic.v1.errors._NumberBoundError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.NumberNotLtError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.NumberNotLtError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.NumberNotLtError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.NumberNotLtError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"NumberNotMultipleError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.NumberNotMultipleError","name":"NumberNotMultipleError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.NumberNotMultipleError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.NumberNotMultipleError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3],"arg_names":["self","multiple_of"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.errors.NumberNotMultipleError.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3],"arg_names":["self","multiple_of"],"arg_types":["pydantic.v1.errors.NumberNotMultipleError",{".class":"UnionType","items":["builtins.int","builtins.float","decimal.Decimal"],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of NumberNotMultipleError","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.NumberNotMultipleError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.NumberNotMultipleError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.NumberNotMultipleError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.NumberNotMultipleError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Path":{".class":"SymbolTableNode","cross_ref":"pathlib.Path","kind":"Gdef","module_public":false},"PathError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticTypeError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.PathError","name":"PathError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.PathError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.PathError","pydantic.v1.errors.PydanticTypeError","pydantic.v1.errors.PydanticErrorMixin","builtins.TypeError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.PathError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.PathError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.PathError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"PathNotADirectoryError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors._PathValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.PathNotADirectoryError","name":"PathNotADirectoryError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.PathNotADirectoryError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.PathNotADirectoryError","pydantic.v1.errors._PathValueError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.PathNotADirectoryError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.PathNotADirectoryError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.PathNotADirectoryError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.PathNotADirectoryError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"PathNotAFileError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors._PathValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.PathNotAFileError","name":"PathNotAFileError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.PathNotAFileError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.PathNotAFileError","pydantic.v1.errors._PathValueError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.PathNotAFileError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.PathNotAFileError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.PathNotAFileError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.PathNotAFileError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"PathNotExistsError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors._PathValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.PathNotExistsError","name":"PathNotExistsError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.PathNotExistsError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.PathNotExistsError","pydantic.v1.errors._PathValueError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.PathNotExistsError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.PathNotExistsError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.PathNotExistsError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.PathNotExistsError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"PatternError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.PatternError","name":"PatternError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.PatternError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.PatternError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.PatternError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.PatternError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.PatternError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.PatternError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"PyObjectError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticTypeError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.PyObjectError","name":"PyObjectError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.PyObjectError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.PyObjectError","pydantic.v1.errors.PydanticTypeError","pydantic.v1.errors.PydanticErrorMixin","builtins.TypeError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.PyObjectError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.PyObjectError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.PyObjectError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"PydanticErrorMixin":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.PydanticErrorMixin","name":"PydanticErrorMixin","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.PydanticErrorMixin","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.PydanticErrorMixin","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,4],"arg_names":["self","ctx"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.errors.PydanticErrorMixin.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,4],"arg_names":["self","ctx"],"arg_types":["pydantic.v1.errors.PydanticErrorMixin",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of PydanticErrorMixin","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__reduce__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.errors.PydanticErrorMixin.__reduce__","name":"__reduce__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.errors.PydanticErrorMixin"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__reduce__ of PydanticErrorMixin","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":"pydantic.v1.errors.PydanticErrorMixin","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"TupleType","implicit":false,"items":[{".class":"TypeType","item":"pydantic.v1.errors.PydanticErrorMixin"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.DictStrAny"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__str__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.errors.PydanticErrorMixin.__str__","name":"__str__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["pydantic.v1.errors.PydanticErrorMixin"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__str__ of PydanticErrorMixin","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic.v1.errors.PydanticErrorMixin.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic.v1.errors.PydanticErrorMixin.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.PydanticErrorMixin.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.PydanticErrorMixin","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"PydanticTypeError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticErrorMixin","builtins.TypeError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.PydanticTypeError","name":"PydanticTypeError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.PydanticTypeError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.PydanticTypeError","pydantic.v1.errors.PydanticErrorMixin","builtins.TypeError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.PydanticTypeError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.PydanticTypeError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"PydanticValueError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.PydanticValueError","name":"PydanticValueError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.PydanticValueError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.PydanticValueError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.PydanticValueError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef","module_public":false},"SequenceError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticTypeError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.SequenceError","name":"SequenceError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.SequenceError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.SequenceError","pydantic.v1.errors.PydanticTypeError","pydantic.v1.errors.PydanticErrorMixin","builtins.TypeError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.SequenceError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.SequenceError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.SequenceError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Set":{".class":"SymbolTableNode","cross_ref":"typing.Set","kind":"Gdef","module_public":false},"SetError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticTypeError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.SetError","name":"SetError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.SetError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.SetError","pydantic.v1.errors.PydanticTypeError","pydantic.v1.errors.PydanticErrorMixin","builtins.TypeError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.SetError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.SetError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.SetError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"SetMaxLengthError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.SetMaxLengthError","name":"SetMaxLengthError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.SetMaxLengthError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.SetMaxLengthError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3],"arg_names":["self","limit_value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.errors.SetMaxLengthError.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3],"arg_names":["self","limit_value"],"arg_types":["pydantic.v1.errors.SetMaxLengthError","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of SetMaxLengthError","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.SetMaxLengthError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.SetMaxLengthError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.SetMaxLengthError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.SetMaxLengthError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"SetMinLengthError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.SetMinLengthError","name":"SetMinLengthError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.SetMinLengthError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.SetMinLengthError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3],"arg_names":["self","limit_value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.errors.SetMinLengthError.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3],"arg_names":["self","limit_value"],"arg_types":["pydantic.v1.errors.SetMinLengthError","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of SetMinLengthError","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.SetMinLengthError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.SetMinLengthError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.SetMinLengthError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.SetMinLengthError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"StrError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticTypeError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.StrError","name":"StrError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.StrError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.StrError","pydantic.v1.errors.PydanticTypeError","pydantic.v1.errors.PydanticErrorMixin","builtins.TypeError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.StrError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.StrError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.StrError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"StrRegexError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.StrRegexError","name":"StrRegexError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.StrRegexError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.StrRegexError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3],"arg_names":["self","pattern"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.errors.StrRegexError.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3],"arg_names":["self","pattern"],"arg_types":["pydantic.v1.errors.StrRegexError","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of StrRegexError","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.StrRegexError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.StrRegexError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.StrRegexError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.StrRegexError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"StrictBoolError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.StrictBoolError","name":"StrictBoolError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.StrictBoolError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.StrictBoolError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.StrictBoolError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.StrictBoolError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.StrictBoolError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"SubclassError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticTypeError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.SubclassError","name":"SubclassError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.SubclassError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.SubclassError","pydantic.v1.errors.PydanticTypeError","pydantic.v1.errors.PydanticErrorMixin","builtins.TypeError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3],"arg_names":["self","expected_class"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.errors.SubclassError.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3],"arg_names":["self","expected_class"],"arg_types":["pydantic.v1.errors.SubclassError",{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of SubclassError","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.SubclassError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.SubclassError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.SubclassError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.SubclassError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef","module_public":false},"TimeError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.TimeError","name":"TimeError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.TimeError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.TimeError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.TimeError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.TimeError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.TimeError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Tuple":{".class":"SymbolTableNode","cross_ref":"typing.Tuple","kind":"Gdef","module_public":false},"TupleError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticTypeError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.TupleError","name":"TupleError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.TupleError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.TupleError","pydantic.v1.errors.PydanticTypeError","pydantic.v1.errors.PydanticErrorMixin","builtins.TypeError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.TupleError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.TupleError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.TupleError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TupleLengthError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.TupleLengthError","name":"TupleLengthError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.TupleLengthError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.TupleLengthError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,3],"arg_names":["self","actual_length","expected_length"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.errors.TupleLengthError.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3,3],"arg_names":["self","actual_length","expected_length"],"arg_types":["pydantic.v1.errors.TupleLengthError","builtins.int","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of TupleLengthError","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.TupleLengthError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.TupleLengthError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.TupleLengthError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.TupleLengthError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Type":{".class":"SymbolTableNode","cross_ref":"typing.Type","kind":"Gdef","module_public":false},"UUIDError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticTypeError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.UUIDError","name":"UUIDError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.UUIDError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.UUIDError","pydantic.v1.errors.PydanticTypeError","pydantic.v1.errors.PydanticErrorMixin","builtins.TypeError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.UUIDError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.UUIDError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.UUIDError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"UUIDVersionError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.UUIDVersionError","name":"UUIDVersionError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.UUIDVersionError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.UUIDVersionError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3],"arg_names":["self","required_version"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.errors.UUIDVersionError.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3],"arg_names":["self","required_version"],"arg_types":["pydantic.v1.errors.UUIDVersionError","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of UUIDVersionError","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.UUIDVersionError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.UUIDVersionError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.UUIDVersionError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.UUIDVersionError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef","module_public":false},"UrlError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.UrlError","name":"UrlError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.UrlError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.UrlError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.UrlError.code","name":"code","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.UrlError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.UrlError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"UrlExtraError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.UrlError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.UrlExtraError","name":"UrlExtraError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.UrlExtraError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.UrlExtraError","pydantic.v1.errors.UrlError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.UrlExtraError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.UrlExtraError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.UrlExtraError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.UrlExtraError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"UrlHostError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.UrlError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.UrlHostError","name":"UrlHostError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.UrlHostError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.UrlHostError","pydantic.v1.errors.UrlError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.UrlHostError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.UrlHostError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.UrlHostError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.UrlHostError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"UrlHostTldError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.UrlError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.UrlHostTldError","name":"UrlHostTldError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.UrlHostTldError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.UrlHostTldError","pydantic.v1.errors.UrlError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.UrlHostTldError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.UrlHostTldError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.UrlHostTldError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.UrlHostTldError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"UrlPortError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.UrlError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.UrlPortError","name":"UrlPortError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.UrlPortError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.UrlPortError","pydantic.v1.errors.UrlError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.UrlPortError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.UrlPortError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.UrlPortError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.UrlPortError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"UrlSchemeError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.UrlError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.UrlSchemeError","name":"UrlSchemeError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.UrlSchemeError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.UrlSchemeError","pydantic.v1.errors.UrlError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.UrlSchemeError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.UrlSchemeError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.UrlSchemeError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.UrlSchemeError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"UrlSchemePermittedError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.UrlError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.UrlSchemePermittedError","name":"UrlSchemePermittedError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.UrlSchemePermittedError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.UrlSchemePermittedError","pydantic.v1.errors.UrlError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","allowed_schemes"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.errors.UrlSchemePermittedError.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","allowed_schemes"],"arg_types":["pydantic.v1.errors.UrlSchemePermittedError",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of UrlSchemePermittedError","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.UrlSchemePermittedError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.UrlSchemePermittedError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.UrlSchemePermittedError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.UrlSchemePermittedError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"UrlUserInfoError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.UrlError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.UrlUserInfoError","name":"UrlUserInfoError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.UrlUserInfoError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.UrlUserInfoError","pydantic.v1.errors.UrlError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.UrlUserInfoError.code","name":"code","setter_type":null,"type":"builtins.str"}},"msg_template":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.UrlUserInfoError.msg_template","name":"msg_template","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.UrlUserInfoError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.UrlUserInfoError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"WrongConstantError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors.WrongConstantError","name":"WrongConstantError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.WrongConstantError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors.WrongConstantError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","__str__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.errors.WrongConstantError.__str__","name":"__str__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["pydantic.v1.errors.WrongConstantError"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__str__ of WrongConstantError","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"code":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.WrongConstantError.code","name":"code","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors.WrongConstantError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors.WrongConstantError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_NumberBoundError":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors._NumberBoundError","name":"_NumberBoundError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors._NumberBoundError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors._NumberBoundError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3],"arg_names":["self","limit_value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.errors._NumberBoundError.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3],"arg_names":["self","limit_value"],"arg_types":["pydantic.v1.errors._NumberBoundError",{".class":"UnionType","items":["builtins.int","builtins.float","decimal.Decimal"],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of _NumberBoundError","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors._NumberBoundError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors._NumberBoundError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_PathValueError":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.errors.PydanticValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.errors._PathValueError","name":"_PathValueError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors._PathValueError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.errors","mro":["pydantic.v1.errors._PathValueError","pydantic.v1.errors.PydanticValueError","pydantic.v1.errors.PydanticErrorMixin","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3],"arg_names":["self","path"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.errors._PathValueError.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3],"arg_names":["self","path"],"arg_types":["pydantic.v1.errors._PathValueError","pathlib.Path"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of _PathValueError","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.errors._PathValueError.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.errors._PathValueError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.errors.__all__","name":"__all__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.errors.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.errors.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.errors.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.errors.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.errors.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.errors.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"cls_kwargs":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","ctx"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.errors.cls_kwargs","name":"cls_kwargs","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","ctx"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.errors.PydanticErrorMixin"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.DictStrAny"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cls_kwargs","ret_type":"pydantic.v1.errors.PydanticErrorMixin","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"display_as_type":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.display_as_type","kind":"Gdef","module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/errors.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/errors.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/errors.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..2808403f9a79eb22a2cd82d6b31b20058a5189e8 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/errors.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[5,1,2,3,1,1,1,1],"dep_prios":[5,5,5,5,5,30,30,30],"dependencies":["pydantic.v1.typing","decimal","pathlib","typing","builtins","_frozen_importlib","abc","os"],"hash":"ac8c6c94fa48971ca1cbb58c8299d2918842c274","id":"pydantic.v1.errors","ignore_all":true,"interface_hash":"6bcaf19462e0660de5f28206b491734195f1d8ef","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/errors.py","plugin_data":null,"size":17726,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/fields.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/fields.data.json new file mode 100644 index 0000000000000000000000000000000000000000..045eb36b5292adf8813bdd5aae05e1d5d7b35179 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/fields.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic.v1.fields","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","AbstractSetIntStr":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.AbstractSetIntStr","kind":"Gdef"},"Annotated":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Annotated","kind":"Gdef"},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"BaseConfig":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.config.BaseConfig","kind":"Gdef"},"BoolUndefined":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.fields.BoolUndefined","line":94,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["builtins.bool","pydantic.v1.fields.UndefinedType"],"uses_pep604_syntax":false}}},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"CollectionCounter":{".class":"SymbolTableNode","cross_ref":"collections.Counter","kind":"Gdef"},"CollectionsHashable":{".class":"SymbolTableNode","cross_ref":"typing.Hashable","kind":"Gdef"},"CollectionsIterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef"},"ConfigError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.ConfigError","kind":"Gdef"},"Counter":{".class":"SymbolTableNode","cross_ref":"typing.Counter","kind":"Gdef"},"DefaultDict":{".class":"SymbolTableNode","cross_ref":"typing.DefaultDict","kind":"Gdef"},"DeferredType":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.fields.DeferredType","name":"DeferredType","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.fields.DeferredType","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.fields","mro":["pydantic.v1.fields.DeferredType","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.fields.DeferredType.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.fields.DeferredType","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Deque":{".class":"SymbolTableNode","cross_ref":"typing.Deque","kind":"Gdef"},"Dict":{".class":"SymbolTableNode","cross_ref":"typing.Dict","kind":"Gdef"},"ErrorList":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.error_wrappers.ErrorList","kind":"Gdef"},"ErrorWrapper":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.error_wrappers.ErrorWrapper","kind":"Gdef"},"Field":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,4],"arg_names":["default","default_factory","alias","title","description","exclude","include","const","gt","ge","lt","le","multiple_of","allow_inf_nan","max_digits","decimal_places","min_items","max_items","unique_items","min_length","max_length","allow_mutation","regex","discriminator","repr","extra"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.fields.Field","name":"Field","original_first_arg":"default","type":{".class":"CallableType","arg_kinds":[1,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,4],"arg_names":["default","default_factory","alias","title","description","exclude","include","const","gt","ge","lt","le","multiple_of","allow_inf_nan","max_digits","decimal_places","min_items","max_items","unique_items","min_length","max_length","allow_mutation","regex","discriminator","repr","extra"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.NoArgAnyCallable"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AbstractSetIntStr"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.MappingIntStrAny"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AbstractSetIntStr"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.MappingIntStrAny"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"Field","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"FieldInfo":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.utils.Representation"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.fields.FieldInfo","name":"FieldInfo","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.fields.FieldInfo","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.fields","mro":["pydantic.v1.fields.FieldInfo","pydantic.v1.utils.Representation","builtins.object"],"names":{".class":"SymbolTable","__field_constraints__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.fields.FieldInfo.__field_constraints__","name":"__field_constraints__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,4],"arg_names":["self","default","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.fields.FieldInfo.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,4],"arg_names":["self","default","kwargs"],"arg_types":["pydantic.v1.fields.FieldInfo",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of FieldInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr_args__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.fields.FieldInfo.__repr_args__","name":"__repr_args__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.fields.FieldInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr_args__ of FieldInfo","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.ReprArgs"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic.v1.fields.FieldInfo.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_validate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.fields.FieldInfo._validate","name":"_validate","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.fields.FieldInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_validate of FieldInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"alias":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.fields.FieldInfo.alias","name":"alias","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"alias_priority":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.fields.FieldInfo.alias_priority","name":"alias_priority","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"allow_inf_nan":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.fields.FieldInfo.allow_inf_nan","name":"allow_inf_nan","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"allow_mutation":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.fields.FieldInfo.allow_mutation","name":"allow_mutation","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"const":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.fields.FieldInfo.const","name":"const","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"decimal_places":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.fields.FieldInfo.decimal_places","name":"decimal_places","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"default":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.fields.FieldInfo.default","name":"default","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"default_factory":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.fields.FieldInfo.default_factory","name":"default_factory","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"description":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.fields.FieldInfo.description","name":"description","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"discriminator":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.fields.FieldInfo.discriminator","name":"discriminator","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"exclude":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.fields.FieldInfo.exclude","name":"exclude","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"extra":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.fields.FieldInfo.extra","name":"extra","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"ge":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.fields.FieldInfo.ge","name":"ge","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"get_constraints":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.fields.FieldInfo.get_constraints","name":"get_constraints","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.fields.FieldInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_constraints of FieldInfo","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"gt":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.fields.FieldInfo.gt","name":"gt","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"include":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.fields.FieldInfo.include","name":"include","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"le":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.fields.FieldInfo.le","name":"le","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"lt":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.fields.FieldInfo.lt","name":"lt","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"max_digits":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.fields.FieldInfo.max_digits","name":"max_digits","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"max_items":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.fields.FieldInfo.max_items","name":"max_items","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"max_length":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.fields.FieldInfo.max_length","name":"max_length","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"min_items":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.fields.FieldInfo.min_items","name":"min_items","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"min_length":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.fields.FieldInfo.min_length","name":"min_length","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"multiple_of":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.fields.FieldInfo.multiple_of","name":"multiple_of","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"regex":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.fields.FieldInfo.regex","name":"regex","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"repr":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.fields.FieldInfo.repr","name":"repr","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"title":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.fields.FieldInfo.title","name":"title","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"unique_items":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.fields.FieldInfo.unique_items","name":"unique_items","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"update_from_config":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","from_config"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.fields.FieldInfo.update_from_config","name":"update_from_config","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","from_config"],"arg_types":["pydantic.v1.fields.FieldInfo",{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"update_from_config of FieldInfo","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.fields.FieldInfo.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.fields.FieldInfo","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Final":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Final","kind":"Gdef"},"ForwardRef":{".class":"SymbolTableNode","cross_ref":"typing.ForwardRef","kind":"Gdef"},"FrozenSet":{".class":"SymbolTableNode","cross_ref":"typing.FrozenSet","kind":"Gdef"},"Generator":{".class":"SymbolTableNode","cross_ref":"typing.Generator","kind":"Gdef"},"InvalidDiscriminator":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.InvalidDiscriminator","kind":"Gdef"},"Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef"},"Iterator":{".class":"SymbolTableNode","cross_ref":"typing.Iterator","kind":"Gdef"},"Json":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.Json","kind":"Gdef"},"JsonWrapper":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.JsonWrapper","kind":"Gdef"},"List":{".class":"SymbolTableNode","cross_ref":"typing.List","kind":"Gdef"},"LocStr":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.fields.LocStr","line":93,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"},"builtins.str"],"uses_pep604_syntax":false}}},"MAPPING_LIKE_SHAPES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic.v1.fields.MAPPING_LIKE_SHAPES","name":"MAPPING_LIKE_SHAPES","setter_type":null,"type":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.set"}}},"Mapping":{".class":"SymbolTableNode","cross_ref":"typing.Mapping","kind":"Gdef"},"MappingIntStrAny":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.MappingIntStrAny","kind":"Gdef"},"MissingDiscriminator":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.MissingDiscriminator","kind":"Gdef"},"ModelField":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.utils.Representation"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.fields.ModelField","name":"ModelField","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.fields.ModelField","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.fields","mro":["pydantic.v1.fields.ModelField","pydantic.v1.utils.Representation","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,3,3,3,5,5,5,5,5,5],"arg_names":["self","name","type_","class_validators","model_config","default","default_factory","required","final","alias","field_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.fields.ModelField.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,3,3,3,3,5,5,5,5,5,5],"arg_names":["self","name","type_","class_validators","model_config","default","default_factory","required","final","alias","field_info"],"arg_types":["pydantic.v1.fields.ModelField","builtins.str",{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","pydantic.v1.class_validators.Validator"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"TypeType","item":"pydantic.v1.config.BaseConfig"},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.NoArgAnyCallable"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.fields.BoolUndefined"},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["pydantic.v1.fields.FieldInfo",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of ModelField","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr_args__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.fields.ModelField.__repr_args__","name":"__repr_args__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.fields.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr_args__ of ModelField","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.ReprArgs"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic.v1.fields.ModelField.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_apply_validators":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0,0],"arg_names":["self","v","values","loc","cls","validators"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.fields.ModelField._apply_validators","name":"_apply_validators","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0],"arg_names":["self","v","values","loc","cls","validators"],"arg_types":["pydantic.v1.fields.ModelField",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.fields.LocStr"},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.ModelOrDc"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.class_validators.ValidatorsList"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_apply_validators of ModelField","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.fields.ValidateReturn"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_create_sub_type":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,5],"arg_names":["self","type_","name","for_keys"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.fields.ModelField._create_sub_type","name":"_create_sub_type","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,5],"arg_names":["self","type_","name","for_keys"],"arg_types":["pydantic.v1.fields.ModelField",{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},"builtins.str","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_create_sub_type of ModelField","ret_type":"pydantic.v1.fields.ModelField","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_get_field_info":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["field_name","annotation","value","config"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"pydantic.v1.fields.ModelField._get_field_info","name":"_get_field_info","original_first_arg":"field_name","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["field_name","annotation","value","config"],"arg_types":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeType","item":"pydantic.v1.config.BaseConfig"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_field_info of ModelField","ret_type":{".class":"TupleType","implicit":false,"items":["pydantic.v1.fields.FieldInfo",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_staticmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.fields.ModelField._get_field_info","name":"_get_field_info","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["field_name","annotation","value","config"],"arg_types":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeType","item":"pydantic.v1.config.BaseConfig"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_field_info of ModelField","ret_type":{".class":"TupleType","implicit":false,"items":["pydantic.v1.fields.FieldInfo",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"_get_mapping_value":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","original","converted"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.fields.ModelField._get_mapping_value","name":"_get_mapping_value","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","original","converted"],"arg_types":["pydantic.v1.fields.ModelField",{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.fields.T","id":-1,"name":"T","namespace":"pydantic.v1.fields.ModelField._get_mapping_value","upper_bound":"builtins.object","values":[],"variance":0},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_mapping_value of ModelField","ret_type":{".class":"UnionType","items":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.fields.T","id":-1,"name":"T","namespace":"pydantic.v1.fields.ModelField._get_mapping_value","upper_bound":"builtins.object","values":[],"variance":0},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.fields.T","id":-1,"name":"T","namespace":"pydantic.v1.fields.ModelField._get_mapping_value","upper_bound":"builtins.object","values":[],"variance":0}]}}},"_set_default_and_type":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.fields.ModelField._set_default_and_type","name":"_set_default_and_type","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.fields.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_set_default_and_type of ModelField","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_type_analysis":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.fields.ModelField._type_analysis","name":"_type_analysis","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.fields.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_type_analysis of ModelField","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_type_display":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.fields.ModelField._type_display","name":"_type_display","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.fields.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_type_display of ModelField","ret_type":"pydantic.v1.utils.PyObjectStr","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_validate_discriminated_union":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0],"arg_names":["self","v","values","loc","cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.fields.ModelField._validate_discriminated_union","name":"_validate_discriminated_union","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":["self","v","values","loc","cls"],"arg_types":["pydantic.v1.fields.ModelField",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.fields.LocStr"},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.ModelOrDc"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_validate_discriminated_union of ModelField","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.fields.ValidateReturn"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_validate_iterable":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0],"arg_names":["self","v","values","loc","cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.fields.ModelField._validate_iterable","name":"_validate_iterable","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":["self","v","values","loc","cls"],"arg_types":["pydantic.v1.fields.ModelField",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.fields.LocStr"},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.ModelOrDc"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_validate_iterable of ModelField","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.fields.ValidateReturn"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_validate_mapping_like":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0],"arg_names":["self","v","values","loc","cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.fields.ModelField._validate_mapping_like","name":"_validate_mapping_like","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":["self","v","values","loc","cls"],"arg_types":["pydantic.v1.fields.ModelField",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.fields.LocStr"},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.ModelOrDc"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_validate_mapping_like of ModelField","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.fields.ValidateReturn"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_validate_sequence_like":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0],"arg_names":["self","v","values","loc","cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.fields.ModelField._validate_sequence_like","name":"_validate_sequence_like","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":["self","v","values","loc","cls"],"arg_types":["pydantic.v1.fields.ModelField",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.fields.LocStr"},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.ModelOrDc"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_validate_sequence_like of ModelField","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.fields.ValidateReturn"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_validate_singleton":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0],"arg_names":["self","v","values","loc","cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.fields.ModelField._validate_singleton","name":"_validate_singleton","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":["self","v","values","loc","cls"],"arg_types":["pydantic.v1.fields.ModelField",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.fields.LocStr"},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.ModelOrDc"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_validate_singleton of ModelField","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.fields.ValidateReturn"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_validate_tuple":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0],"arg_names":["self","v","values","loc","cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.fields.ModelField._validate_tuple","name":"_validate_tuple","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":["self","v","values","loc","cls"],"arg_types":["pydantic.v1.fields.ModelField",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.fields.LocStr"},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.ModelOrDc"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_validate_tuple of ModelField","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.fields.ValidateReturn"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"alias":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic.v1.fields.ModelField.alias","name":"alias","setter_type":null,"type":"builtins.str"}},"allow_none":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic.v1.fields.ModelField.allow_none","name":"allow_none","setter_type":null,"type":"builtins.bool"}},"alt_alias":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.fields.ModelField.alt_alias","name":"alt_alias","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.fields.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"alt_alias of ModelField","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"pydantic.v1.fields.ModelField.alt_alias","name":"alt_alias","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.fields.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"alt_alias of ModelField","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"annotation":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.fields.ModelField.annotation","name":"annotation","setter_type":null,"type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}}},"class_validators":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.fields.ModelField.class_validators","name":"class_validators","setter_type":null,"type":{".class":"Instance","args":["builtins.str","pydantic.v1.class_validators.Validator"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"default":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic.v1.fields.ModelField.default","name":"default","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"default_factory":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic.v1.fields.ModelField.default_factory","name":"default_factory","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.NoArgAnyCallable"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"discriminator_alias":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic.v1.fields.ModelField.discriminator_alias","name":"discriminator_alias","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"discriminator_key":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic.v1.fields.ModelField.discriminator_key","name":"discriminator_key","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"field_info":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic.v1.fields.ModelField.field_info","name":"field_info","setter_type":null,"type":"pydantic.v1.fields.FieldInfo"}},"final":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic.v1.fields.ModelField.final","name":"final","setter_type":null,"type":"builtins.bool"}},"get_default":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.fields.ModelField.get_default","name":"get_default","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.fields.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_default of ModelField","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"has_alias":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic.v1.fields.ModelField.has_alias","name":"has_alias","setter_type":null,"type":"builtins.bool"}},"infer":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,3,3,3,3],"arg_names":["cls","name","value","annotation","class_validators","config"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.fields.ModelField.infer","name":"infer","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,3,3,3,3,3],"arg_names":["cls","name","value","annotation","class_validators","config"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.fields.ModelField"},"builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","pydantic.v1.class_validators.Validator"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"TypeType","item":"pydantic.v1.config.BaseConfig"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"infer of ModelField","ret_type":"pydantic.v1.fields.ModelField","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.fields.ModelField.infer","name":"infer","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,3,3,3,3,3],"arg_names":["cls","name","value","annotation","class_validators","config"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.fields.ModelField"},"builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","pydantic.v1.class_validators.Validator"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"TypeType","item":"pydantic.v1.config.BaseConfig"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"infer of ModelField","ret_type":"pydantic.v1.fields.ModelField","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"is_complex":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.fields.ModelField.is_complex","name":"is_complex","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.fields.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_complex of ModelField","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"key_field":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic.v1.fields.ModelField.key_field","name":"key_field","setter_type":null,"type":{".class":"UnionType","items":["pydantic.v1.fields.ModelField",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"model_config":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.fields.ModelField.model_config","name":"model_config","setter_type":null,"type":{".class":"TypeType","item":"pydantic.v1.config.BaseConfig"}}},"name":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic.v1.fields.ModelField.name","name":"name","setter_type":null,"type":"builtins.str"}},"outer_type_":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic.v1.fields.ModelField.outer_type_","name":"outer_type_","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"parse_json":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic.v1.fields.ModelField.parse_json","name":"parse_json","setter_type":null,"type":"builtins.bool"}},"populate_validators":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.fields.ModelField.populate_validators","name":"populate_validators","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.fields.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"populate_validators of ModelField","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"post_validators":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic.v1.fields.ModelField.post_validators","name":"post_validators","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.class_validators.ValidatorsList"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"pre_validators":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic.v1.fields.ModelField.pre_validators","name":"pre_validators","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.class_validators.ValidatorsList"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"prepare":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.fields.ModelField.prepare","name":"prepare","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.fields.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prepare of ModelField","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"prepare_discriminated_union_sub_fields":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.fields.ModelField.prepare_discriminated_union_sub_fields","name":"prepare_discriminated_union_sub_fields","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.fields.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"prepare_discriminated_union_sub_fields of ModelField","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"required":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic.v1.fields.ModelField.required","name":"required","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.fields.BoolUndefined"}}},"set_config":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","config"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.fields.ModelField.set_config","name":"set_config","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","config"],"arg_types":["pydantic.v1.fields.ModelField",{".class":"TypeType","item":"pydantic.v1.config.BaseConfig"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"set_config of ModelField","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"shape":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic.v1.fields.ModelField.shape","name":"shape","setter_type":null,"type":"builtins.int"}},"sub_fields":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic.v1.fields.ModelField.sub_fields","name":"sub_fields","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["pydantic.v1.fields.ModelField"],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"sub_fields_mapping":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic.v1.fields.ModelField.sub_fields_mapping","name":"sub_fields_mapping","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","pydantic.v1.fields.ModelField"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"type_":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic.v1.fields.ModelField.type_","name":"type_","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"validate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,3,5],"arg_names":["self","v","values","loc","cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.fields.ModelField.validate","name":"validate","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,3,5],"arg_names":["self","v","values","loc","cls"],"arg_types":["pydantic.v1.fields.ModelField",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.fields.LocStr"},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.ModelOrDc"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate of ModelField","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.fields.ValidateReturn"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"validate_always":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic.v1.fields.ModelField.validate_always","name":"validate_always","setter_type":null,"type":"builtins.bool"}},"validators":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic.v1.fields.ModelField.validators","name":"validators","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.class_validators.ValidatorsList"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.fields.ModelField.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.fields.ModelField","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ModelOrDc":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.ModelOrDc","kind":"Gdef"},"ModelPrivateAttr":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.utils.Representation"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.fields.ModelPrivateAttr","name":"ModelPrivateAttr","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.fields.ModelPrivateAttr","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.fields","mro":["pydantic.v1.fields.ModelPrivateAttr","pydantic.v1.utils.Representation","builtins.object"],"names":{".class":"SymbolTable","__eq__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.fields.ModelPrivateAttr.__eq__","name":"__eq__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["pydantic.v1.fields.ModelPrivateAttr",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__eq__ of ModelPrivateAttr","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,5],"arg_names":["self","default","default_factory"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.fields.ModelPrivateAttr.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,5],"arg_names":["self","default","default_factory"],"arg_types":["pydantic.v1.fields.ModelPrivateAttr",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.NoArgAnyCallable"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of ModelPrivateAttr","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic.v1.fields.ModelPrivateAttr.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"default":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.fields.ModelPrivateAttr.default","name":"default","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"default_factory":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.fields.ModelPrivateAttr.default_factory","name":"default_factory","setter_type":null,"type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.NoArgAnyCallable"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"get_default":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.fields.ModelPrivateAttr.get_default","name":"get_default","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.fields.ModelPrivateAttr"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_default of ModelPrivateAttr","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.fields.ModelPrivateAttr.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.fields.ModelPrivateAttr","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"NoArgAnyCallable":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.NoArgAnyCallable","kind":"Gdef"},"NoneIsNotAllowedError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.NoneIsNotAllowedError","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"Pattern":{".class":"SymbolTableNode","cross_ref":"re.Pattern","kind":"Gdef"},"PrivateAttr":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1,5],"arg_names":["default","default_factory"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.fields.PrivateAttr","name":"PrivateAttr","original_first_arg":"default","type":{".class":"CallableType","arg_kinds":[1,5],"arg_names":["default","default_factory"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.NoArgAnyCallable"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"PrivateAttr","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"PyObjectStr":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.PyObjectStr","kind":"Gdef"},"ReprArgs":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.ReprArgs","kind":"Gdef"},"Representation":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.Representation","kind":"Gdef"},"Required":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic.v1.fields.Required","name":"Required","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"SHAPE_COUNTER":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.fields.SHAPE_COUNTER","name":"SHAPE_COUNTER","setter_type":null,"type":"builtins.int"}},"SHAPE_DEFAULTDICT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.fields.SHAPE_DEFAULTDICT","name":"SHAPE_DEFAULTDICT","setter_type":null,"type":"builtins.int"}},"SHAPE_DEQUE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.fields.SHAPE_DEQUE","name":"SHAPE_DEQUE","setter_type":null,"type":"builtins.int"}},"SHAPE_DICT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.fields.SHAPE_DICT","name":"SHAPE_DICT","setter_type":null,"type":"builtins.int"}},"SHAPE_FROZENSET":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.fields.SHAPE_FROZENSET","name":"SHAPE_FROZENSET","setter_type":null,"type":"builtins.int"}},"SHAPE_GENERIC":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.fields.SHAPE_GENERIC","name":"SHAPE_GENERIC","setter_type":null,"type":"builtins.int"}},"SHAPE_ITERABLE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.fields.SHAPE_ITERABLE","name":"SHAPE_ITERABLE","setter_type":null,"type":"builtins.int"}},"SHAPE_LIST":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.fields.SHAPE_LIST","name":"SHAPE_LIST","setter_type":null,"type":"builtins.int"}},"SHAPE_MAPPING":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.fields.SHAPE_MAPPING","name":"SHAPE_MAPPING","setter_type":null,"type":"builtins.int"}},"SHAPE_NAME_LOOKUP":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.fields.SHAPE_NAME_LOOKUP","name":"SHAPE_NAME_LOOKUP","setter_type":null,"type":{".class":"Instance","args":["builtins.int","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"SHAPE_SEQUENCE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.fields.SHAPE_SEQUENCE","name":"SHAPE_SEQUENCE","setter_type":null,"type":"builtins.int"}},"SHAPE_SET":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.fields.SHAPE_SET","name":"SHAPE_SET","setter_type":null,"type":"builtins.int"}},"SHAPE_SINGLETON":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.fields.SHAPE_SINGLETON","name":"SHAPE_SINGLETON","setter_type":null,"type":"builtins.int"}},"SHAPE_TUPLE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.fields.SHAPE_TUPLE","name":"SHAPE_TUPLE","setter_type":null,"type":"builtins.int"}},"SHAPE_TUPLE_ELLIPSIS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.fields.SHAPE_TUPLE_ELLIPSIS","name":"SHAPE_TUPLE_ELLIPSIS","setter_type":null,"type":"builtins.int"}},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef"},"Set":{".class":"SymbolTableNode","cross_ref":"typing.Set","kind":"Gdef"},"T":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.fields.T","name":"T","upper_bound":"builtins.object","values":[],"variance":0}},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"Tuple":{".class":"SymbolTableNode","cross_ref":"typing.Tuple","kind":"Gdef"},"Type":{".class":"SymbolTableNode","cross_ref":"typing.Type","kind":"Gdef"},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef"},"Undefined":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.fields.Undefined","name":"Undefined","setter_type":null,"type":"pydantic.v1.fields.UndefinedType"}},"UndefinedType":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.fields.UndefinedType","name":"UndefinedType","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.fields.UndefinedType","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.fields","mro":["pydantic.v1.fields.UndefinedType","builtins.object"],"names":{".class":"SymbolTable","__copy__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.fields.UndefinedType.__copy__","name":"__copy__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.fields.T","id":-1,"name":"T","namespace":"pydantic.v1.fields.UndefinedType.__copy__","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__copy__ of UndefinedType","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.fields.T","id":-1,"name":"T","namespace":"pydantic.v1.fields.UndefinedType.__copy__","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.fields.T","id":-1,"name":"T","namespace":"pydantic.v1.fields.UndefinedType.__copy__","upper_bound":"builtins.object","values":[],"variance":0}]}}},"__deepcopy__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","_"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.fields.UndefinedType.__deepcopy__","name":"__deepcopy__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","_"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.fields.T","id":-1,"name":"T","namespace":"pydantic.v1.fields.UndefinedType.__deepcopy__","upper_bound":"builtins.object","values":[],"variance":0},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__deepcopy__ of UndefinedType","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.fields.T","id":-1,"name":"T","namespace":"pydantic.v1.fields.UndefinedType.__deepcopy__","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.fields.T","id":-1,"name":"T","namespace":"pydantic.v1.fields.UndefinedType.__deepcopy__","upper_bound":"builtins.object","values":[],"variance":0}]}}},"__reduce__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.fields.UndefinedType.__reduce__","name":"__reduce__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.fields.UndefinedType"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__reduce__ of UndefinedType","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.fields.UndefinedType.__repr__","name":"__repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["pydantic.v1.fields.UndefinedType"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr__ of UndefinedType","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.fields.UndefinedType.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.fields.UndefinedType","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"ValidateReturn":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.fields.ValidateReturn","line":92,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.error_wrappers.ErrorList"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"Validator":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.class_validators.Validator","kind":"Gdef"},"ValidatorsList":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.class_validators.ValidatorsList","kind":"Gdef"},"ValueItems":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.ValueItems","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.fields.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.fields.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.fields.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.fields.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.fields.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.fields.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"constant_validator":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.validators.constant_validator","kind":"Gdef"},"convert_generics":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.convert_generics","kind":"Gdef"},"copy":{".class":"SymbolTableNode","cross_ref":"copy","kind":"Gdef"},"defaultdict":{".class":"SymbolTableNode","cross_ref":"collections.defaultdict","kind":"Gdef"},"deque":{".class":"SymbolTableNode","cross_ref":"collections.deque","kind":"Gdef"},"dict_validator":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.validators.dict_validator","kind":"Gdef"},"display_as_type":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.display_as_type","kind":"Gdef"},"errors_":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors","kind":"Gdef"},"find_validators":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.validators.find_validators","kind":"Gdef"},"get_args":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.get_args","kind":"Gdef"},"get_discriminator_alias_and_values":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.get_discriminator_alias_and_values","kind":"Gdef"},"get_origin":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.get_origin","kind":"Gdef"},"get_unique_discriminator_alias":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.get_unique_discriminator_alias","kind":"Gdef"},"is_finalvar":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.is_finalvar","kind":"Gdef"},"is_finalvar_with_default_val":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["type_","val"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.fields.is_finalvar_with_default_val","name":"is_finalvar_with_default_val","original_first_arg":"type_","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["type_","val"],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_finalvar_with_default_val","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_literal_type":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.is_literal_type","kind":"Gdef"},"is_new_type":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.is_new_type","kind":"Gdef"},"is_none_type":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.is_none_type","kind":"Gdef"},"is_typeddict":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.is_typeddict","kind":"Gdef"},"is_typeddict_special":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.is_typeddict_special","kind":"Gdef"},"is_union":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.is_union","kind":"Gdef"},"lenient_isinstance":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.lenient_isinstance","kind":"Gdef"},"lenient_issubclass":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.lenient_issubclass","kind":"Gdef"},"make_generic_validator":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.class_validators.make_generic_validator","kind":"Gdef"},"new_type_supertype":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.new_type_supertype","kind":"Gdef"},"prep_validators":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.class_validators.prep_validators","kind":"Gdef"},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef"},"sequence_like":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.sequence_like","kind":"Gdef"},"smart_deepcopy":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.smart_deepcopy","kind":"Gdef"},"validate_json":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.validators.validate_json","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/fields.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/fields.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/fields.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..e012bf49a34be080ad4de56b7eaf7538443d66ff --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/fields.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[31,32,33,35,36,51,62,87,493,1163,4,31,1,2,3,5,29,1,1,1,1],"dep_prios":[5,5,5,5,5,5,5,25,20,20,5,20,10,10,5,5,5,5,30,30,30],"dependencies":["pydantic.v1.errors","pydantic.v1.class_validators","pydantic.v1.error_wrappers","pydantic.v1.types","pydantic.v1.typing","pydantic.v1.utils","pydantic.v1.validators","pydantic.v1.config","pydantic.v1.schema","pydantic.v1.main","collections.abc","pydantic.v1","copy","re","collections","typing","typing_extensions","builtins","_frozen_importlib","abc","pydantic.v1.dataclasses"],"hash":"a21d6b4f6d5c84c2211be2afcb9d94c2f315d425","id":"pydantic.v1.fields","ignore_all":true,"interface_hash":"6cc2ad37895c44cff996731e6c8e89f3eecd27eb","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/fields.py","plugin_data":null,"size":50649,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/json.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/json.data.json new file mode 100644 index 0000000000000000000000000000000000000000..ec9fb1556bb958af66e1c2d07f2fd99aead289b5 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/json.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic.v1.json","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_public":false},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef","module_public":false},"Color":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.color.Color","kind":"Gdef","module_public":false},"Decimal":{".class":"SymbolTableNode","cross_ref":"decimal.Decimal","kind":"Gdef","module_public":false},"Dict":{".class":"SymbolTableNode","cross_ref":"typing.Dict","kind":"Gdef","module_public":false},"ENCODERS_BY_TYPE":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic.v1.json.ENCODERS_BY_TYPE","name":"ENCODERS_BY_TYPE","setter_type":null,"type":{".class":"Instance","args":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"Enum":{".class":"SymbolTableNode","cross_ref":"enum.Enum","kind":"Gdef","module_public":false},"GeneratorType":{".class":"SymbolTableNode","cross_ref":"types.GeneratorType","kind":"Gdef","module_public":false},"IPv4Address":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv4Address","kind":"Gdef","module_public":false},"IPv4Interface":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv4Interface","kind":"Gdef","module_public":false},"IPv4Network":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv4Network","kind":"Gdef","module_public":false},"IPv6Address":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv6Address","kind":"Gdef","module_public":false},"IPv6Interface":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv6Interface","kind":"Gdef","module_public":false},"IPv6Network":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv6Network","kind":"Gdef","module_public":false},"NameEmail":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.networks.NameEmail","kind":"Gdef","module_public":false},"Path":{".class":"SymbolTableNode","cross_ref":"pathlib.Path","kind":"Gdef","module_public":false},"Pattern":{".class":"SymbolTableNode","cross_ref":"re.Pattern","kind":"Gdef","module_public":false},"SecretBytes":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.SecretBytes","kind":"Gdef","module_public":false},"SecretStr":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.SecretStr","kind":"Gdef","module_public":false},"Type":{".class":"SymbolTableNode","cross_ref":"typing.Type","kind":"Gdef","module_public":false},"UUID":{".class":"SymbolTableNode","cross_ref":"uuid.UUID","kind":"Gdef","module_public":false},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef","module_public":false},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.json.__all__","name":"__all__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.json.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.json.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.json.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.json.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.json.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.json.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"custom_pydantic_encoder":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["type_encoders","obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.json.custom_pydantic_encoder","name":"custom_pydantic_encoder","original_first_arg":"type_encoders","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["type_encoders","obj"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"custom_pydantic_encoder","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"datetime":{".class":"SymbolTableNode","cross_ref":"datetime","kind":"Gdef","module_public":false},"decimal_encoder":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["dec_value"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.json.decimal_encoder","name":"decimal_encoder","original_first_arg":"dec_value","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dec_value"],"arg_types":["decimal.Decimal"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"decimal_encoder","ret_type":{".class":"UnionType","items":["builtins.int","builtins.float"],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"deque":{".class":"SymbolTableNode","cross_ref":"collections.deque","kind":"Gdef","module_public":false},"isoformat":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["o"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.json.isoformat","name":"isoformat","original_first_arg":"o","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["o"],"arg_types":[{".class":"UnionType","items":["datetime.date","datetime.time"],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"isoformat","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"pydantic_encoder":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.json.pydantic_encoder","name":"pydantic_encoder","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pydantic_encoder","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"timedelta_isoformat":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["td"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.json.timedelta_isoformat","name":"timedelta_isoformat","original_first_arg":"td","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["td"],"arg_types":["datetime.timedelta"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"timedelta_isoformat","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/json.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/json.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/json.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..99feb4208b21eac0c603416adf57d7c6d6fcdc23 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/json.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[12,13,14,1,2,3,4,5,6,7,8,9,10,1,1,1,1,1,1],"dep_prios":[5,5,5,10,5,5,5,5,5,5,5,5,5,5,30,30,30,30,30],"dependencies":["pydantic.v1.color","pydantic.v1.networks","pydantic.v1.types","datetime","collections","decimal","enum","ipaddress","pathlib","re","types","typing","uuid","builtins","_frozen_importlib","abc","os","pydantic.v1.utils","typing_extensions"],"hash":"3e625208cdce138ab966f47c91a58d47a4ffe1a6","id":"pydantic.v1.json","ignore_all":true,"interface_hash":"58bbbafceef922f9db8973ffd53ed95d17c30a6f","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/json.py","plugin_data":null,"size":3390,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/main.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/main.data.json new file mode 100644 index 0000000000000000000000000000000000000000..1446120299cc74961c8ecc6c4c7caa2f13f9ed20 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/main.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic.v1.main","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","ABCMeta":{".class":"SymbolTableNode","cross_ref":"abc.ABCMeta","kind":"Gdef","module_public":false},"ANNOTATED_FIELD_UNTOUCHED_TYPES":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic.v1.main.ANNOTATED_FIELD_UNTOUCHED_TYPES","name":"ANNOTATED_FIELD_UNTOUCHED_TYPES","setter_type":null,"type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}}},"AbstractSet":{".class":"SymbolTableNode","cross_ref":"typing.AbstractSet","kind":"Gdef","module_public":false},"AbstractSetIntStr":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.AbstractSetIntStr","kind":"Gdef","module_public":false},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_public":false},"AnyCallable":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.AnyCallable","kind":"Gdef","module_public":false},"AnyClassMethod":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.AnyClassMethod","kind":"Gdef","module_public":false},"BaseConfig":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.config.BaseConfig","kind":"Gdef","module_public":false},"BaseModel":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.utils.Representation"],"dataclass_transform_spec":null,"declared_metaclass":"pydantic.v1.main.ModelMetaclass","defn":{".class":"ClassDef","fullname":"pydantic.v1.main.BaseModel","name":"BaseModel","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.main.BaseModel","has_param_spec_type":false,"metaclass_type":"pydantic.v1.main.ModelMetaclass","metadata":{"dataclass":{"attributes":[],"frozen":false},"dataclass_tag":{}},"module_name":"pydantic.v1.main","mro":["pydantic.v1.main.BaseModel","pydantic.v1.utils.Representation","builtins.object"],"names":{".class":"SymbolTable","Config":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.main.BaseModel.Config","name":"Config","setter_type":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.type","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":"pydantic.v1.config.BaseConfig","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__class_vars__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready"],"fullname":"pydantic.v1.main.BaseModel.__class_vars__","name":"__class_vars__","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.SetStr"}}},"__config__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready","has_explicit_value"],"fullname":"pydantic.v1.main.BaseModel.__config__","name":"__config__","setter_type":null,"type":{".class":"TypeType","item":"pydantic.v1.config.BaseConfig"}}},"__custom_root_type__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready","has_explicit_value"],"fullname":"pydantic.v1.main.BaseModel.__custom_root_type__","name":"__custom_root_type__","setter_type":null,"type":"builtins.bool"}},"__dataclass_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_classvar","is_ready"],"fullname":"pydantic.v1.main.BaseModel.__dataclass_fields__","name":"__dataclass_fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}},"plugin_generated":true},"__doc__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.main.BaseModel.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__eq__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.main.BaseModel.__eq__","name":"__eq__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["pydantic.v1.main.BaseModel",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__eq__ of BaseModel","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__exclude_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready","has_explicit_value"],"fullname":"pydantic.v1.main.BaseModel.__exclude_fields__","name":"__exclude_fields__","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"__fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready","has_explicit_value"],"fullname":"pydantic.v1.main.BaseModel.__fields__","name":"__fields__","setter_type":null,"type":{".class":"Instance","args":["builtins.str","pydantic.v1.fields.ModelField"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__fields_set__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready","has_explicit_value"],"fullname":"pydantic.v1.main.BaseModel.__fields_set__","name":"__fields_set__","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.SetStr"}}},"__get_validators__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.main.BaseModel.__get_validators__","name":"__get_validators__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.main.BaseModel"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of BaseModel","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.main.BaseModel.__get_validators__","name":"__get_validators__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.main.BaseModel"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of BaseModel","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__getstate__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.main.BaseModel.__getstate__","name":"__getstate__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.main.BaseModel"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getstate__ of BaseModel","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.DictAny"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__include_fields__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready","has_explicit_value"],"fullname":"pydantic.v1.main.BaseModel.__include_fields__","name":"__include_fields__","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,4],"arg_names":["__pydantic_self__","data"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.main.BaseModel.__init__","name":"__init__","original_first_arg":"__pydantic_self__","type":{".class":"CallableType","arg_kinds":[0,4],"arg_names":["__pydantic_self__","data"],"arg_types":["pydantic.v1.main.BaseModel",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of BaseModel","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__iter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.main.BaseModel.__iter__","name":"__iter__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["pydantic.v1.main.BaseModel"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iter__ of BaseModel","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.TupleGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__json_encoder__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready","has_explicit_value"],"fullname":"pydantic.v1.main.BaseModel.__json_encoder__","name":"__json_encoder__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__mypy-replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"pydantic.v1.main.BaseModel.__mypy-replace","name":"__mypy-replace","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of BaseModel","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_staticmethod","is_ready"],"fullname":"pydantic.v1.main.BaseModel.__mypy-replace","name":"__mypy-replace","setter_type":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__mypy-replace of BaseModel","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"plugin_generated":true},"__post_root_validators__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready"],"fullname":"pydantic.v1.main.BaseModel.__post_root_validators__","name":"__post_root_validators__","setter_type":null,"type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.bool",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyCallable"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"builtins.list"}}},"__pre_root_validators__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready"],"fullname":"pydantic.v1.main.BaseModel.__pre_root_validators__","name":"__pre_root_validators__","setter_type":null,"type":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyCallable"}],"extra_attrs":null,"type_ref":"builtins.list"}}},"__private_attributes__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready"],"fullname":"pydantic.v1.main.BaseModel.__private_attributes__","name":"__private_attributes__","setter_type":null,"type":{".class":"Instance","args":["builtins.str","pydantic.v1.fields.ModelPrivateAttr"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__repr_args__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.main.BaseModel.__repr_args__","name":"__repr_args__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.main.BaseModel"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr_args__ of BaseModel","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.ReprArgs"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__schema_cache__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready","has_explicit_value"],"fullname":"pydantic.v1.main.BaseModel.__schema_cache__","name":"__schema_cache__","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.DictAny"}}},"__setattr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","name","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated"],"fullname":"pydantic.v1.main.BaseModel.__setattr__","name":"__setattr__","original_first_arg":"self","type":null},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred"],"fullname":"pydantic.v1.main.BaseModel.__setattr__","name":"__setattr__","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}}}},"__setstate__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","state"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.main.BaseModel.__setstate__","name":"__setstate__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","state"],"arg_types":["pydantic.v1.main.BaseModel",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.DictAny"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__setstate__ of BaseModel","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__signature__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready"],"fullname":"pydantic.v1.main.BaseModel.__signature__","name":"__signature__","setter_type":null,"type":"inspect.Signature"}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic.v1.main.BaseModel.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"__try_update_forward_refs__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,4],"arg_names":["cls","localns"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.main.BaseModel.__try_update_forward_refs__","name":"__try_update_forward_refs__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,4],"arg_names":["cls","localns"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.main.BaseModel"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__try_update_forward_refs__ of BaseModel","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.main.BaseModel.__try_update_forward_refs__","name":"__try_update_forward_refs__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,4],"arg_names":["cls","localns"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.main.BaseModel"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__try_update_forward_refs__ of BaseModel","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__validators__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready","has_explicit_value"],"fullname":"pydantic.v1.main.BaseModel.__validators__","name":"__validators__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyCallable"}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_calculate_keys":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1],"arg_names":["self","include","exclude","exclude_unset","update"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.main.BaseModel._calculate_keys","name":"_calculate_keys","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["self","include","exclude","exclude_unset","update"],"arg_types":["pydantic.v1.main.BaseModel",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.MappingIntStrAny"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.MappingIntStrAny"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.DictStrAny"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_calculate_keys of BaseModel","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.AbstractSet"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_copy_and_set_values":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,3],"arg_names":["self","values","fields_set","deep"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.main.BaseModel._copy_and_set_values","name":"_copy_and_set_values","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,3],"arg_names":["self","values","fields_set","deep"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel._copy_and_set_values","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.DictStrAny"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.SetStr"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_copy_and_set_values of BaseModel","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel._copy_and_set_values","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel._copy_and_set_values","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}]}}},"_decompose_class":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated"],"fullname":"pydantic.v1.main.BaseModel._decompose_class","name":"_decompose_class","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","obj"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel._decompose_class","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_decompose_class of BaseModel","ret_type":"pydantic.v1.utils.GetterDict","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel._decompose_class","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.main.BaseModel._decompose_class","name":"_decompose_class","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","obj"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel._decompose_class","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_decompose_class of BaseModel","ret_type":"pydantic.v1.utils.GetterDict","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel._decompose_class","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}]}}}},"_enforce_dict_if_root":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.main.BaseModel._enforce_dict_if_root","name":"_enforce_dict_if_root","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","obj"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.main.BaseModel"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_enforce_dict_if_root of BaseModel","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.main.BaseModel._enforce_dict_if_root","name":"_enforce_dict_if_root","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","obj"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.main.BaseModel"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_enforce_dict_if_root of BaseModel","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"_get_value":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0,0,0,0,0],"arg_names":["cls","v","to_dict","by_alias","include","exclude","exclude_unset","exclude_defaults","exclude_none"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated"],"fullname":"pydantic.v1.main.BaseModel._get_value","name":"_get_value","original_first_arg":"cls","type":null},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.main.BaseModel._get_value","name":"_get_value","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}}}},"_init_private_attributes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.main.BaseModel._init_private_attributes","name":"_init_private_attributes","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.main.BaseModel"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_init_private_attributes of BaseModel","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_iter":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1,1],"arg_names":["self","to_dict","by_alias","include","exclude","exclude_unset","exclude_defaults","exclude_none"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.main.BaseModel._iter","name":"_iter","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,1],"arg_names":["self","to_dict","by_alias","include","exclude","exclude_unset","exclude_defaults","exclude_none"],"arg_types":["pydantic.v1.main.BaseModel","builtins.bool","builtins.bool",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AbstractSetIntStr"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.MappingIntStrAny"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AbstractSetIntStr"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.MappingIntStrAny"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool","builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_iter of BaseModel","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.TupleGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"construct":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,4],"arg_names":["cls","_fields_set","values"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated"],"fullname":"pydantic.v1.main.BaseModel.construct","name":"construct","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,1,4],"arg_names":["cls","_fields_set","values"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.construct","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.SetStr"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"construct of BaseModel","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.construct","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.construct","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.main.BaseModel.construct","name":"construct","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,4],"arg_names":["cls","_fields_set","values"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.construct","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.SetStr"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"construct of BaseModel","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.construct","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.construct","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}]}}}},"copy":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5],"arg_names":["self","include","exclude","update","deep"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.main.BaseModel.copy","name":"copy","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5],"arg_names":["self","include","exclude","update","deep"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.copy","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AbstractSetIntStr"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.MappingIntStrAny"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AbstractSetIntStr"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.MappingIntStrAny"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.DictStrAny"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"copy of BaseModel","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.copy","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.copy","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}]}}},"dict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5,5,5,5],"arg_names":["self","include","exclude","by_alias","skip_defaults","exclude_unset","exclude_defaults","exclude_none"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.main.BaseModel.dict","name":"dict","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5,5,5,5],"arg_names":["self","include","exclude","by_alias","skip_defaults","exclude_unset","exclude_defaults","exclude_none"],"arg_types":["pydantic.v1.main.BaseModel",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AbstractSetIntStr"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.MappingIntStrAny"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AbstractSetIntStr"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.MappingIntStrAny"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool","builtins.bool","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dict of BaseModel","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.DictStrAny"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"from_orm":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated"],"fullname":"pydantic.v1.main.BaseModel.from_orm","name":"from_orm","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","obj"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.from_orm","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"from_orm of BaseModel","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.from_orm","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.from_orm","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.main.BaseModel.from_orm","name":"from_orm","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","obj"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.from_orm","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"from_orm of BaseModel","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.from_orm","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.from_orm","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}]}}}},"json":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5,5,5,5,5,5,4],"arg_names":["self","include","exclude","by_alias","skip_defaults","exclude_unset","exclude_defaults","exclude_none","encoder","models_as_dict","dumps_kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.main.BaseModel.json","name":"json","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5,5,5,5,5,5,4],"arg_names":["self","include","exclude","by_alias","skip_defaults","exclude_unset","exclude_defaults","exclude_none","encoder","models_as_dict","dumps_kwargs"],"arg_types":["pydantic.v1.main.BaseModel",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AbstractSetIntStr"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.MappingIntStrAny"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AbstractSetIntStr"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.MappingIntStrAny"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool","builtins.bool","builtins.bool",{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"json of BaseModel","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"parse_file":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5],"arg_names":["cls","path","content_type","encoding","proto","allow_pickle"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated"],"fullname":"pydantic.v1.main.BaseModel.parse_file","name":"parse_file","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5],"arg_names":["cls","path","content_type","encoding","proto","allow_pickle"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.parse_file","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}},{".class":"UnionType","items":["builtins.str","pathlib.Path"],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str",{".class":"UnionType","items":["pydantic.v1.parse.Protocol",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parse_file of BaseModel","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.parse_file","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.parse_file","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.main.BaseModel.parse_file","name":"parse_file","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5],"arg_names":["cls","path","content_type","encoding","proto","allow_pickle"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.parse_file","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}},{".class":"UnionType","items":["builtins.str","pathlib.Path"],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str",{".class":"UnionType","items":["pydantic.v1.parse.Protocol",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parse_file of BaseModel","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.parse_file","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.parse_file","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}]}}}},"parse_obj":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated"],"fullname":"pydantic.v1.main.BaseModel.parse_obj","name":"parse_obj","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","obj"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.parse_obj","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parse_obj of BaseModel","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.parse_obj","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.parse_obj","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.main.BaseModel.parse_obj","name":"parse_obj","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","obj"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.parse_obj","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parse_obj of BaseModel","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.parse_obj","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.parse_obj","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}]}}}},"parse_raw":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5],"arg_names":["cls","b","content_type","encoding","proto","allow_pickle"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated"],"fullname":"pydantic.v1.main.BaseModel.parse_raw","name":"parse_raw","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5],"arg_names":["cls","b","content_type","encoding","proto","allow_pickle"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.parse_raw","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.StrBytes"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str",{".class":"UnionType","items":["pydantic.v1.parse.Protocol",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parse_raw of BaseModel","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.parse_raw","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.parse_raw","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.main.BaseModel.parse_raw","name":"parse_raw","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5],"arg_names":["cls","b","content_type","encoding","proto","allow_pickle"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.parse_raw","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.StrBytes"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str",{".class":"UnionType","items":["pydantic.v1.parse.Protocol",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parse_raw of BaseModel","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.parse_raw","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.parse_raw","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}]}}}},"schema":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["cls","by_alias","ref_template"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.main.BaseModel.schema","name":"schema","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["cls","by_alias","ref_template"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.main.BaseModel"},"builtins.bool","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"schema of BaseModel","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.DictStrAny"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.main.BaseModel.schema","name":"schema","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["cls","by_alias","ref_template"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.main.BaseModel"},"builtins.bool","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"schema of BaseModel","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.DictStrAny"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"schema_json":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,4],"arg_names":["cls","by_alias","ref_template","dumps_kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.main.BaseModel.schema_json","name":"schema_json","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,5,5,4],"arg_names":["cls","by_alias","ref_template","dumps_kwargs"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.main.BaseModel"},"builtins.bool","builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"schema_json of BaseModel","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.main.BaseModel.schema_json","name":"schema_json","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5,4],"arg_names":["cls","by_alias","ref_template","dumps_kwargs"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.main.BaseModel"},"builtins.bool","builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"schema_json of BaseModel","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"update_forward_refs":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,4],"arg_names":["cls","localns"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.main.BaseModel.update_forward_refs","name":"update_forward_refs","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,4],"arg_names":["cls","localns"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.main.BaseModel"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"update_forward_refs of BaseModel","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.main.BaseModel.update_forward_refs","name":"update_forward_refs","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,4],"arg_names":["cls","localns"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.main.BaseModel"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"update_forward_refs of BaseModel","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"validate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated"],"fullname":"pydantic.v1.main.BaseModel.validate","name":"validate","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","value"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.validate","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate of BaseModel","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.validate","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.validate","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.main.BaseModel.validate","name":"validate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","value"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.validate","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate of BaseModel","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.validate","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.BaseModel.validate","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.BaseModel.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef","module_public":false},"CallableGenerator":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.CallableGenerator","kind":"Gdef","module_public":false},"ClassAttribute":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.ClassAttribute","kind":"Gdef","module_public":false},"ClassVar":{".class":"SymbolTableNode","cross_ref":"typing.ClassVar","kind":"Gdef","module_public":false},"ConfigError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.ConfigError","kind":"Gdef","module_public":false},"DUNDER_ATTRIBUTES":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.DUNDER_ATTRIBUTES","kind":"Gdef","module_public":false},"Dict":{".class":"SymbolTableNode","cross_ref":"typing.Dict","kind":"Gdef","module_public":false},"DictAny":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.DictAny","kind":"Gdef","module_public":false},"DictError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.DictError","kind":"Gdef","module_public":false},"DictStrAny":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.DictStrAny","kind":"Gdef","module_public":false},"Enum":{".class":"SymbolTableNode","cross_ref":"enum.Enum","kind":"Gdef","module_public":false},"ErrorWrapper":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.error_wrappers.ErrorWrapper","kind":"Gdef","module_public":false},"Extra":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.config.Extra","kind":"Gdef","module_public":false},"ExtraError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.ExtraError","kind":"Gdef","module_public":false},"Field":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.fields.Field","kind":"Gdef","module_public":false},"FunctionType":{".class":"SymbolTableNode","cross_ref":"types.FunctionType","kind":"Gdef","module_public":false},"GetterDict":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.GetterDict","kind":"Gdef","module_public":false},"List":{".class":"SymbolTableNode","cross_ref":"typing.List","kind":"Gdef","module_public":false},"MAPPING_LIKE_SHAPES":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.fields.MAPPING_LIKE_SHAPES","kind":"Gdef","module_public":false},"Mapping":{".class":"SymbolTableNode","cross_ref":"typing.Mapping","kind":"Gdef","module_public":false},"MappingIntStrAny":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.MappingIntStrAny","kind":"Gdef","module_public":false},"MissingError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.MissingError","kind":"Gdef","module_public":false},"Model":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","name":"Model","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}},"ModelField":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.fields.ModelField","kind":"Gdef","module_public":false},"ModelMetaclass":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["abc.ABCMeta"],"dataclass_transform_spec":{"eq_default":true,"field_specifiers":["pydantic.v1.fields.Field"],"frozen_default":false,"kw_only_default":true,"order_default":false},"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.main.ModelMetaclass","name":"ModelMetaclass","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.main.ModelMetaclass","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.main","mro":["pydantic.v1.main.ModelMetaclass","abc.ABCMeta","builtins.type","builtins.object"],"names":{".class":"SymbolTable","__instancecheck__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","instance"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.main.ModelMetaclass.__instancecheck__","name":"__instancecheck__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","instance"],"arg_types":["pydantic.v1.main.ModelMetaclass",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__instancecheck__ of ModelMetaclass","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__new__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,4],"arg_names":["mcs","name","bases","namespace","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"pydantic.v1.main.ModelMetaclass.__new__","name":"__new__","original_first_arg":"mcs","type":null},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred"],"fullname":"pydantic.v1.main.ModelMetaclass.__new__","name":"__new__","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.ModelMetaclass.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.main.ModelMetaclass","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ModelOrDc":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.ModelOrDc","kind":"Gdef","module_public":false},"ModelPrivateAttr":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.fields.ModelPrivateAttr","kind":"Gdef","module_public":false},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef","module_public":false},"Path":{".class":"SymbolTableNode","cross_ref":"pathlib.Path","kind":"Gdef","module_public":false},"PrivateAttr":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.fields.PrivateAttr","kind":"Gdef","module_public":false},"Protocol":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.parse.Protocol","kind":"Gdef","module_public":false},"PyObject":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.PyObject","kind":"Gdef","module_public":false},"ROOT_KEY":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.ROOT_KEY","kind":"Gdef","module_public":false},"ReprArgs":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.ReprArgs","kind":"Gdef","module_public":false},"Representation":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.Representation","kind":"Gdef","module_public":false},"SetStr":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.SetStr","kind":"Gdef","module_public":false},"Signature":{".class":"SymbolTableNode","cross_ref":"inspect.Signature","kind":"Gdef","module_public":false},"StrBytes":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.StrBytes","kind":"Gdef","module_public":false},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef","module_public":false},"Tuple":{".class":"SymbolTableNode","cross_ref":"typing.Tuple","kind":"Gdef","module_public":false},"TupleGenerator":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.TupleGenerator","kind":"Gdef","module_public":false},"Type":{".class":"SymbolTableNode","cross_ref":"typing.Type","kind":"Gdef","module_public":false},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_public":false},"UNTOUCHED_TYPES":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic.v1.main.UNTOUCHED_TYPES","name":"UNTOUCHED_TYPES","setter_type":null,"type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}}},"Undefined":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.fields.Undefined","kind":"Gdef","module_public":false},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef","module_public":false},"ValidationError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.error_wrappers.ValidationError","kind":"Gdef","module_public":false},"ValidatorGroup":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.class_validators.ValidatorGroup","kind":"Gdef","module_public":false},"ValidatorListDict":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.class_validators.ValidatorListDict","kind":"Gdef","module_public":false},"ValueItems":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.ValueItems","kind":"Gdef","module_public":false},"_T":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main._T","name":"_T","upper_bound":"builtins.object","values":[],"variance":0}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.main.__all__","name":"__all__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.main.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.main.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.main.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.main.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.main.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.main.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_is_base_model_class_defined":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.main._is_base_model_class_defined","name":"_is_base_model_class_defined","setter_type":null,"type":"builtins.bool"}},"_missing":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.main._missing","name":"_missing","setter_type":null,"type":"builtins.object"}},"cast":{".class":"SymbolTableNode","cross_ref":"typing.cast","kind":"Gdef","module_public":false},"create_model":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"pydantic.v1.main.create_model","impl":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5,5,5,4],"arg_names":[null,"__config__","__base__","__module__","__validators__","__cls_kwargs__","__slots__","field_definitions"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload"],"fullname":"pydantic.v1.main.create_model","name":"create_model","original_first_arg":"__model_name","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5,5,5,4],"arg_names":[null,"__config__","__base__","__module__","__validators__","__cls_kwargs__","__slots__","field_definitions"],"arg_types":["builtins.str",{".class":"UnionType","items":[{".class":"TypeType","item":"pydantic.v1.config.BaseConfig"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.create_model","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}},{".class":"Instance","args":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.create_model","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}}],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyClassMethod"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"create_model","ret_type":{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.create_model","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.create_model","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}]}},"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5,5,4],"arg_names":[null,"__config__","__base__","__module__","__validators__","__cls_kwargs__","field_definitions"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"pydantic.v1.main.create_model","name":"create_model","original_first_arg":"__model_name","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5,5,4],"arg_names":[null,"__config__","__base__","__module__","__validators__","__cls_kwargs__","field_definitions"],"arg_types":["builtins.str",{".class":"UnionType","items":[{".class":"TypeType","item":"pydantic.v1.config.BaseConfig"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"NoneType"},"builtins.str",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyClassMethod"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"create_model","ret_type":{".class":"TypeType","item":"pydantic.v1.main.BaseModel"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.main.create_model","name":"create_model","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,5,5,5,5,4],"arg_names":[null,"__config__","__base__","__module__","__validators__","__cls_kwargs__","field_definitions"],"arg_types":["builtins.str",{".class":"UnionType","items":[{".class":"TypeType","item":"pydantic.v1.config.BaseConfig"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"NoneType"},"builtins.str",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyClassMethod"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"create_model","ret_type":{".class":"TypeType","item":"pydantic.v1.main.BaseModel"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,3,5,5,5,4],"arg_names":[null,"__config__","__base__","__module__","__validators__","__cls_kwargs__","field_definitions"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"pydantic.v1.main.create_model","name":"create_model","original_first_arg":"__model_name","type":{".class":"CallableType","arg_kinds":[0,5,3,5,5,5,4],"arg_names":[null,"__config__","__base__","__module__","__validators__","__cls_kwargs__","field_definitions"],"arg_types":["builtins.str",{".class":"UnionType","items":[{".class":"TypeType","item":"pydantic.v1.config.BaseConfig"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.create_model#1","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}},{".class":"Instance","args":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.create_model#1","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":false},"builtins.str",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyClassMethod"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"create_model","ret_type":{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.create_model#1","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.create_model#1","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.main.create_model","name":"create_model","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,5,3,5,5,5,4],"arg_names":[null,"__config__","__base__","__module__","__validators__","__cls_kwargs__","field_definitions"],"arg_types":["builtins.str",{".class":"UnionType","items":[{".class":"TypeType","item":"pydantic.v1.config.BaseConfig"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.create_model#1","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}},{".class":"Instance","args":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.create_model#1","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":false},"builtins.str",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyClassMethod"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"create_model","ret_type":{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.create_model#1","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.create_model#1","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,5,5,5,5,5,4],"arg_names":[null,"__config__","__base__","__module__","__validators__","__cls_kwargs__","field_definitions"],"arg_types":["builtins.str",{".class":"UnionType","items":[{".class":"TypeType","item":"pydantic.v1.config.BaseConfig"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"NoneType"},"builtins.str",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyClassMethod"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"create_model","ret_type":{".class":"TypeType","item":"pydantic.v1.main.BaseModel"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,5,3,5,5,5,4],"arg_names":[null,"__config__","__base__","__module__","__validators__","__cls_kwargs__","field_definitions"],"arg_types":["builtins.str",{".class":"UnionType","items":[{".class":"TypeType","item":"pydantic.v1.config.BaseConfig"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.create_model#1","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}},{".class":"Instance","args":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.create_model#1","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":false},"builtins.str",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyClassMethod"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"create_model","ret_type":{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.create_model#1","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.main.Model","id":-1,"name":"Model","namespace":"pydantic.v1.main.create_model#1","upper_bound":"pydantic.v1.main.BaseModel","values":[],"variance":0}]}]}}},"custom_pydantic_encoder":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.json.custom_pydantic_encoder","kind":"Gdef","module_public":false},"dataclass_transform":{".class":"SymbolTableNode","cross_ref":"typing_extensions.dataclass_transform","kind":"Gdef","module_public":false},"deepcopy":{".class":"SymbolTableNode","cross_ref":"copy.deepcopy","kind":"Gdef","module_public":false},"default_ref_template":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.schema.default_ref_template","kind":"Gdef","module_public":false},"extract_root_validators":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.class_validators.extract_root_validators","kind":"Gdef","module_public":false},"extract_validators":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.class_validators.extract_validators","kind":"Gdef","module_public":false},"generate_hash_function":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["frozen"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.main.generate_hash_function","name":"generate_hash_function","original_first_arg":"frozen","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["frozen"],"arg_types":["builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"generate_hash_function","ret_type":{".class":"UnionType","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"generate_model_signature":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.generate_model_signature","kind":"Gdef","module_public":false},"get_args":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.get_args","kind":"Gdef","module_public":false},"get_origin":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.get_origin","kind":"Gdef","module_public":false},"inherit_config":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.config.inherit_config","kind":"Gdef","module_public":false},"inherit_validators":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.class_validators.inherit_validators","kind":"Gdef","module_public":false},"is_classvar":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.is_classvar","kind":"Gdef","module_public":false},"is_finalvar_with_default_val":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.fields.is_finalvar_with_default_val","kind":"Gdef","module_public":false},"is_namedtuple":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.is_namedtuple","kind":"Gdef","module_public":false},"is_union":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.is_union","kind":"Gdef","module_public":false},"is_valid_field":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.is_valid_field","kind":"Gdef","module_public":false},"is_valid_private_name":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.is_valid_private_name","kind":"Gdef","module_public":false},"lenient_issubclass":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.lenient_issubclass","kind":"Gdef","module_public":false},"load_file":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.parse.load_file","kind":"Gdef","module_public":false},"load_str_bytes":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.parse.load_str_bytes","kind":"Gdef","module_public":false},"model_schema":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.schema.model_schema","kind":"Gdef","module_public":false},"no_type_check":{".class":"SymbolTableNode","cross_ref":"typing.no_type_check","kind":"Gdef","module_public":false},"object_setattr":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.main.object_setattr","name":"object_setattr","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,null,null],"arg_types":["builtins.object","builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_public":false},"partial":{".class":"SymbolTableNode","cross_ref":"functools.partial","kind":"Gdef","module_public":false},"prepare_class":{".class":"SymbolTableNode","cross_ref":"types.prepare_class","kind":"Gdef","module_public":false},"prepare_config":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.config.prepare_config","kind":"Gdef","module_public":false},"pydantic_encoder":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.json.pydantic_encoder","kind":"Gdef","module_public":false},"resolve_annotations":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.resolve_annotations","kind":"Gdef","module_public":false},"resolve_bases":{".class":"SymbolTableNode","cross_ref":"types.resolve_bases","kind":"Gdef","module_public":false},"sequence_like":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.sequence_like","kind":"Gdef","module_public":false},"smart_deepcopy":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.smart_deepcopy","kind":"Gdef","module_public":false},"unique_list":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.unique_list","kind":"Gdef","module_public":false},"update_model_forward_refs":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.update_model_forward_refs","kind":"Gdef","module_public":false},"validate_custom_root_type":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["fields"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.main.validate_custom_root_type","name":"validate_custom_root_type","original_first_arg":"fields","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["fields"],"arg_types":[{".class":"Instance","args":["builtins.str","pydantic.v1.fields.ModelField"],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate_custom_root_type","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"validate_field_name":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.validate_field_name","kind":"Gdef","module_public":false},"validate_model":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["model","input_data","cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.main.validate_model","name":"validate_model","original_first_arg":"model","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["model","input_data","cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.main.BaseModel"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.DictStrAny"},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.ModelOrDc"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate_model","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.DictStrAny"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.SetStr"},{".class":"UnionType","items":["pydantic.v1.error_wrappers.ValidationError",{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"warnings":{".class":"SymbolTableNode","cross_ref":"warnings","kind":"Gdef","module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/main.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/main.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/main.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..f7fe214155e9acac4b11bbea26ef63019d91f03a --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/main.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[29,30,31,32,33,42,43,44,45,46,56,1,2,3,4,5,6,7,8,27,74,1,1,1,1,1],"dep_prios":[5,5,5,5,5,5,5,5,5,5,5,10,5,5,5,5,5,5,5,5,25,5,30,30,30,30],"dependencies":["pydantic.v1.class_validators","pydantic.v1.config","pydantic.v1.error_wrappers","pydantic.v1.errors","pydantic.v1.fields","pydantic.v1.json","pydantic.v1.parse","pydantic.v1.schema","pydantic.v1.types","pydantic.v1.typing","pydantic.v1.utils","warnings","abc","copy","enum","functools","pathlib","types","typing","typing_extensions","inspect","builtins","_frozen_importlib","_typeshed","os","pydantic.v1.dataclasses"],"hash":"5cca17c950bfee8b93915123442227b06a836849","id":"pydantic.v1.main","ignore_all":true,"interface_hash":"c3716bd953df25138ea4a4b5479967ed3b0830ba","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/main.py","plugin_data":null,"size":44824,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/networks.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/networks.data.json new file mode 100644 index 0000000000000000000000000000000000000000..23cd66cd63dfc0b262793e2f12ae2054565d0d5c --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/networks.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic.v1.networks","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","AmqpDsn":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.networks.AnyUrl"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.networks.AmqpDsn","name":"AmqpDsn","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.networks.AmqpDsn","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic.v1.networks","mro":["pydantic.v1.networks.AmqpDsn","pydantic.v1.networks.AnyUrl","builtins.str","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","allowed_schemes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.networks.AmqpDsn.allowed_schemes","name":"allowed_schemes","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"host_required":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.networks.AmqpDsn.host_required","name":"host_required","setter_type":null,"type":"builtins.bool"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.networks.AmqpDsn.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.networks.AmqpDsn","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_public":false},"AnyCallable":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.AnyCallable","kind":"Gdef","module_public":false},"AnyHttpUrl":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.networks.AnyUrl"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.networks.AnyHttpUrl","name":"AnyHttpUrl","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.networks.AnyHttpUrl","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic.v1.networks","mro":["pydantic.v1.networks.AnyHttpUrl","pydantic.v1.networks.AnyUrl","builtins.str","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic.v1.networks.AnyHttpUrl.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"allowed_schemes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.networks.AnyHttpUrl.allowed_schemes","name":"allowed_schemes","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.networks.AnyHttpUrl.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.networks.AnyHttpUrl","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"AnyUrl":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.str"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.networks.AnyUrl","name":"AnyUrl","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.networks.AnyUrl","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic.v1.networks","mro":["pydantic.v1.networks.AnyUrl","builtins.str","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","__get_validators__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.networks.AnyUrl.__get_validators__","name":"__get_validators__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.AnyUrl"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of AnyUrl","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.networks.AnyUrl.__get_validators__","name":"__get_validators__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.AnyUrl"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of AnyUrl","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,3,5,5,5,5,5,5,5,5,5],"arg_names":["self","url","scheme","user","password","host","tld","host_type","port","path","query","fragment"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.networks.AnyUrl.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,3,5,5,5,5,5,5,5,5,5],"arg_names":["self","url","scheme","user","password","host","tld","host_type","port","path","query","fragment"],"arg_types":["pydantic.v1.networks.AnyUrl","builtins.str","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of AnyUrl","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__modify_schema__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","field_schema"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.networks.AnyUrl.__modify_schema__","name":"__modify_schema__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field_schema"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.AnyUrl"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__modify_schema__ of AnyUrl","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.networks.AnyUrl.__modify_schema__","name":"__modify_schema__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field_schema"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.AnyUrl"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__modify_schema__ of AnyUrl","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__new__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,4],"arg_names":["cls","url","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"pydantic.v1.networks.AnyUrl.__new__","name":"__new__","original_first_arg":"cls","type":null},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred"],"fullname":"pydantic.v1.networks.AnyUrl.__new__","name":"__new__","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}}}},"__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.networks.AnyUrl.__repr__","name":"__repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["pydantic.v1.networks.AnyUrl"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr__ of AnyUrl","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic.v1.networks.AnyUrl.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_build_url":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["cls","m","url","parts"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.networks.AnyUrl._build_url","name":"_build_url","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["cls","m","url","parts"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.AnyUrl"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Match"},"builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_build_url of AnyUrl","ret_type":"pydantic.v1.networks.AnyUrl","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.networks.AnyUrl._build_url","name":"_build_url","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["cls","m","url","parts"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.AnyUrl"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Match"},"builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_build_url of AnyUrl","ret_type":"pydantic.v1.networks.AnyUrl","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"_match_url":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["url"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"pydantic.v1.networks.AnyUrl._match_url","name":"_match_url","original_first_arg":"url","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["url"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_match_url of AnyUrl","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Match"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_staticmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.networks.AnyUrl._match_url","name":"_match_url","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["url"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_match_url of AnyUrl","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Match"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"_validate_port":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["port"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"pydantic.v1.networks.AnyUrl._validate_port","name":"_validate_port","original_first_arg":"port","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["port"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_validate_port of AnyUrl","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_staticmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.networks.AnyUrl._validate_port","name":"_validate_port","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["port"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_validate_port of AnyUrl","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"allowed_schemes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.networks.AnyUrl.allowed_schemes","name":"allowed_schemes","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Collection"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"apply_default_parts":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","parts"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.networks.AnyUrl.apply_default_parts","name":"apply_default_parts","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","parts"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.AnyUrl"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"apply_default_parts of AnyUrl","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.networks.AnyUrl.apply_default_parts","name":"apply_default_parts","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","parts"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.AnyUrl"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"apply_default_parts of AnyUrl","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"build":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,5,5,3,5,5,5,5,4],"arg_names":["cls","scheme","user","password","host","port","path","query","fragment","_kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.networks.AnyUrl.build","name":"build","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,3,5,5,3,5,5,5,5,4],"arg_names":["cls","scheme","user","password","host","port","path","query","fragment","_kwargs"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.AnyUrl"},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"build of AnyUrl","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.networks.AnyUrl.build","name":"build","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,3,5,5,3,5,5,5,5,4],"arg_names":["cls","scheme","user","password","host","port","path","query","fragment","_kwargs"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.AnyUrl"},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"build of AnyUrl","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"fragment":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.networks.AnyUrl.fragment","name":"fragment","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"get_default_parts":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["parts"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"pydantic.v1.networks.AnyUrl.get_default_parts","name":"get_default_parts","original_first_arg":"parts","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["parts"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_default_parts of AnyUrl","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_staticmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.networks.AnyUrl.get_default_parts","name":"get_default_parts","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["parts"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_default_parts of AnyUrl","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"hidden_parts":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.networks.AnyUrl.hidden_parts","name":"hidden_parts","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"host":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.networks.AnyUrl.host","name":"host","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"host_required":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.networks.AnyUrl.host_required","name":"host_required","setter_type":null,"type":"builtins.bool"}},"host_type":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.networks.AnyUrl.host_type","name":"host_type","setter_type":null,"type":"builtins.str"}},"max_length":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.networks.AnyUrl.max_length","name":"max_length","setter_type":null,"type":"builtins.int"}},"min_length":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.networks.AnyUrl.min_length","name":"min_length","setter_type":null,"type":"builtins.int"}},"password":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.networks.AnyUrl.password","name":"password","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"path":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.networks.AnyUrl.path","name":"path","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"port":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.networks.AnyUrl.port","name":"port","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"query":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.networks.AnyUrl.query","name":"query","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"scheme":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.networks.AnyUrl.scheme","name":"scheme","setter_type":null,"type":"builtins.str"}},"strip_whitespace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.networks.AnyUrl.strip_whitespace","name":"strip_whitespace","setter_type":null,"type":"builtins.bool"}},"tld":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.networks.AnyUrl.tld","name":"tld","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"tld_required":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.networks.AnyUrl.tld_required","name":"tld_required","setter_type":null,"type":"builtins.bool"}},"user":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.networks.AnyUrl.user","name":"user","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"user_required":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.networks.AnyUrl.user_required","name":"user_required","setter_type":null,"type":"builtins.bool"}},"validate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["cls","value","field","config"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.networks.AnyUrl.validate","name":"validate","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["cls","value","field","config"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.AnyUrl"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"pydantic.v1.fields.ModelField","pydantic.v1.config.BaseConfig"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate of AnyUrl","ret_type":"pydantic.v1.networks.AnyUrl","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.networks.AnyUrl.validate","name":"validate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["cls","value","field","config"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.AnyUrl"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"pydantic.v1.fields.ModelField","pydantic.v1.config.BaseConfig"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate of AnyUrl","ret_type":"pydantic.v1.networks.AnyUrl","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"validate_host":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","parts"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.networks.AnyUrl.validate_host","name":"validate_host","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","parts"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.AnyUrl"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate_host of AnyUrl","ret_type":{".class":"TupleType","implicit":false,"items":["builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str","builtins.bool"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.networks.AnyUrl.validate_host","name":"validate_host","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","parts"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.AnyUrl"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate_host of AnyUrl","ret_type":{".class":"TupleType","implicit":false,"items":["builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str","builtins.bool"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"validate_parts":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["cls","parts","validate_port"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.networks.AnyUrl.validate_parts","name":"validate_parts","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["cls","parts","validate_port"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.AnyUrl"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate_parts of AnyUrl","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.networks.AnyUrl.validate_parts","name":"validate_parts","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["cls","parts","validate_port"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.AnyUrl"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate_parts of AnyUrl","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.networks.AnyUrl.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.networks.AnyUrl","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"BaseConfig":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.config.BaseConfig","kind":"Gdef","module_public":false},"CallableGenerator":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.networks.CallableGenerator","line":42,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyCallable"},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Generator"}}},"CockroachDsn":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.networks.AnyUrl"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.networks.CockroachDsn","name":"CockroachDsn","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.networks.CockroachDsn","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic.v1.networks","mro":["pydantic.v1.networks.CockroachDsn","pydantic.v1.networks.AnyUrl","builtins.str","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","allowed_schemes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.networks.CockroachDsn.allowed_schemes","name":"allowed_schemes","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"user_required":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.networks.CockroachDsn.user_required","name":"user_required","setter_type":null,"type":"builtins.bool"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.networks.CockroachDsn.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.networks.CockroachDsn","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Collection":{".class":"SymbolTableNode","cross_ref":"typing.Collection","kind":"Gdef","module_public":false},"Dict":{".class":"SymbolTableNode","cross_ref":"typing.Dict","kind":"Gdef","module_public":false},"EmailStr":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.str"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.networks.EmailStr","name":"EmailStr","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.networks.EmailStr","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic.v1.networks","mro":["pydantic.v1.networks.EmailStr","builtins.str","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","__get_validators__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.networks.EmailStr.__get_validators__","name":"__get_validators__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.EmailStr"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of EmailStr","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.networks.EmailStr.__get_validators__","name":"__get_validators__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.EmailStr"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of EmailStr","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__modify_schema__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","field_schema"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.networks.EmailStr.__modify_schema__","name":"__modify_schema__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field_schema"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.EmailStr"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__modify_schema__ of EmailStr","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.networks.EmailStr.__modify_schema__","name":"__modify_schema__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field_schema"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.EmailStr"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__modify_schema__ of EmailStr","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"validate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.networks.EmailStr.validate","name":"validate","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","value"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.EmailStr"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate of EmailStr","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.networks.EmailStr.validate","name":"validate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","value"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.EmailStr"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate of EmailStr","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.networks.EmailStr.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.networks.EmailStr","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"FileUrl":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.networks.AnyUrl"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.networks.FileUrl","name":"FileUrl","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.networks.FileUrl","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic.v1.networks","mro":["pydantic.v1.networks.FileUrl","pydantic.v1.networks.AnyUrl","builtins.str","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic.v1.networks.FileUrl.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"allowed_schemes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.networks.FileUrl.allowed_schemes","name":"allowed_schemes","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"host_required":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.networks.FileUrl.host_required","name":"host_required","setter_type":null,"type":"builtins.bool"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.networks.FileUrl.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.networks.FileUrl","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Generator":{".class":"SymbolTableNode","cross_ref":"typing.Generator","kind":"Gdef","module_public":false},"HostParts":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.networks.HostParts","name":"HostParts","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.networks.HostParts","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.networks","mro":["pydantic.v1.networks.HostParts","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["host","builtins.str"],["tld",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],["host_type",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],["port",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],["rebuild","builtins.bool"]],"readonly_keys":[],"required_keys":[]}}},"HttpUrl":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.networks.AnyHttpUrl"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.networks.HttpUrl","name":"HttpUrl","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.networks.HttpUrl","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic.v1.networks","mro":["pydantic.v1.networks.HttpUrl","pydantic.v1.networks.AnyHttpUrl","pydantic.v1.networks.AnyUrl","builtins.str","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","get_default_parts":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["parts"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"pydantic.v1.networks.HttpUrl.get_default_parts","name":"get_default_parts","original_first_arg":"parts","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["parts"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_default_parts of HttpUrl","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_staticmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.networks.HttpUrl.get_default_parts","name":"get_default_parts","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["parts"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_default_parts of HttpUrl","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"hidden_parts":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.networks.HttpUrl.hidden_parts","name":"hidden_parts","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"max_length":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.networks.HttpUrl.max_length","name":"max_length","setter_type":null,"type":"builtins.int"}},"tld_required":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.networks.HttpUrl.tld_required","name":"tld_required","setter_type":null,"type":"builtins.bool"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.networks.HttpUrl.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.networks.HttpUrl","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"IPv4Address":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv4Address","kind":"Gdef","module_public":false},"IPv4Interface":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv4Interface","kind":"Gdef","module_public":false},"IPv4Network":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv4Network","kind":"Gdef","module_public":false},"IPv6Address":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv6Address","kind":"Gdef","module_public":false},"IPv6Interface":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv6Interface","kind":"Gdef","module_public":false},"IPv6Network":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv6Network","kind":"Gdef","module_public":false},"IPvAnyAddress":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["ipaddress._BaseAddress"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.networks.IPvAnyAddress","name":"IPvAnyAddress","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.networks.IPvAnyAddress","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.networks","mro":["pydantic.v1.networks.IPvAnyAddress","ipaddress._BaseAddress","ipaddress._IPAddressBase","builtins.object"],"names":{".class":"SymbolTable","__get_validators__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.networks.IPvAnyAddress.__get_validators__","name":"__get_validators__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.IPvAnyAddress"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of IPvAnyAddress","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.networks.IPvAnyAddress.__get_validators__","name":"__get_validators__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.IPvAnyAddress"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of IPvAnyAddress","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__modify_schema__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","field_schema"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.networks.IPvAnyAddress.__modify_schema__","name":"__modify_schema__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field_schema"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.IPvAnyAddress"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__modify_schema__ of IPvAnyAddress","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.networks.IPvAnyAddress.__modify_schema__","name":"__modify_schema__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field_schema"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.IPvAnyAddress"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__modify_schema__ of IPvAnyAddress","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic.v1.networks.IPvAnyAddress.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"validate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.networks.IPvAnyAddress.validate","name":"validate","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","value"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.IPvAnyAddress"},{".class":"UnionType","items":["builtins.str","builtins.bytes","builtins.int"],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate of IPvAnyAddress","ret_type":{".class":"UnionType","items":["ipaddress.IPv4Address","ipaddress.IPv6Address"],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.networks.IPvAnyAddress.validate","name":"validate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","value"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.IPvAnyAddress"},{".class":"UnionType","items":["builtins.str","builtins.bytes","builtins.int"],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate of IPvAnyAddress","ret_type":{".class":"UnionType","items":["ipaddress.IPv4Address","ipaddress.IPv6Address"],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.networks.IPvAnyAddress.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.networks.IPvAnyAddress","values":[],"variance":0},"slots":[],"tuple_type":null,"type_vars":[],"typeddict_type":null}},"IPvAnyInterface":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["ipaddress._BaseAddress"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.networks.IPvAnyInterface","name":"IPvAnyInterface","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.networks.IPvAnyInterface","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.networks","mro":["pydantic.v1.networks.IPvAnyInterface","ipaddress._BaseAddress","ipaddress._IPAddressBase","builtins.object"],"names":{".class":"SymbolTable","__get_validators__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.networks.IPvAnyInterface.__get_validators__","name":"__get_validators__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.IPvAnyInterface"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of IPvAnyInterface","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.networks.IPvAnyInterface.__get_validators__","name":"__get_validators__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.IPvAnyInterface"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of IPvAnyInterface","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__modify_schema__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","field_schema"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.networks.IPvAnyInterface.__modify_schema__","name":"__modify_schema__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field_schema"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.IPvAnyInterface"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__modify_schema__ of IPvAnyInterface","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.networks.IPvAnyInterface.__modify_schema__","name":"__modify_schema__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field_schema"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.IPvAnyInterface"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__modify_schema__ of IPvAnyInterface","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic.v1.networks.IPvAnyInterface.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"validate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.networks.IPvAnyInterface.validate","name":"validate","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","value"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.IPvAnyInterface"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.NetworkType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate of IPvAnyInterface","ret_type":{".class":"UnionType","items":["ipaddress.IPv4Interface","ipaddress.IPv6Interface"],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.networks.IPvAnyInterface.validate","name":"validate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","value"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.IPvAnyInterface"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.NetworkType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate of IPvAnyInterface","ret_type":{".class":"UnionType","items":["ipaddress.IPv4Interface","ipaddress.IPv6Interface"],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.networks.IPvAnyInterface.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.networks.IPvAnyInterface","values":[],"variance":0},"slots":[],"tuple_type":null,"type_vars":[],"typeddict_type":null}},"IPvAnyNetwork":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"ipaddress._BaseNetwork"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.networks.IPvAnyNetwork","name":"IPvAnyNetwork","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.networks.IPvAnyNetwork","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.networks","mro":["pydantic.v1.networks.IPvAnyNetwork","ipaddress._BaseNetwork","ipaddress._IPAddressBase","builtins.object"],"names":{".class":"SymbolTable","__get_validators__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.networks.IPvAnyNetwork.__get_validators__","name":"__get_validators__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.IPvAnyNetwork"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of IPvAnyNetwork","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.networks.IPvAnyNetwork.__get_validators__","name":"__get_validators__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.IPvAnyNetwork"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of IPvAnyNetwork","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__modify_schema__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","field_schema"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.networks.IPvAnyNetwork.__modify_schema__","name":"__modify_schema__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field_schema"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.IPvAnyNetwork"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__modify_schema__ of IPvAnyNetwork","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.networks.IPvAnyNetwork.__modify_schema__","name":"__modify_schema__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field_schema"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.IPvAnyNetwork"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__modify_schema__ of IPvAnyNetwork","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"validate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.networks.IPvAnyNetwork.validate","name":"validate","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","value"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.IPvAnyNetwork"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.NetworkType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate of IPvAnyNetwork","ret_type":{".class":"UnionType","items":["ipaddress.IPv4Network","ipaddress.IPv6Network"],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.networks.IPvAnyNetwork.validate","name":"validate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","value"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.IPvAnyNetwork"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.NetworkType"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate of IPvAnyNetwork","ret_type":{".class":"UnionType","items":["ipaddress.IPv4Network","ipaddress.IPv6Network"],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.networks.IPvAnyNetwork.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.networks.IPvAnyNetwork","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"KafkaDsn":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.networks.AnyUrl"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.networks.KafkaDsn","name":"KafkaDsn","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.networks.KafkaDsn","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic.v1.networks","mro":["pydantic.v1.networks.KafkaDsn","pydantic.v1.networks.AnyUrl","builtins.str","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","allowed_schemes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.networks.KafkaDsn.allowed_schemes","name":"allowed_schemes","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"get_default_parts":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["parts"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"pydantic.v1.networks.KafkaDsn.get_default_parts","name":"get_default_parts","original_first_arg":"parts","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["parts"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_default_parts of KafkaDsn","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_staticmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.networks.KafkaDsn.get_default_parts","name":"get_default_parts","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["parts"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_default_parts of KafkaDsn","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.networks.KafkaDsn.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.networks.KafkaDsn","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"List":{".class":"SymbolTableNode","cross_ref":"typing.List","kind":"Gdef","module_public":false},"MAX_EMAIL_LENGTH":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.networks.MAX_EMAIL_LENGTH","name":"MAX_EMAIL_LENGTH","setter_type":null,"type":"builtins.int"}},"Match":{".class":"SymbolTableNode","cross_ref":"re.Match","kind":"Gdef","module_public":false},"ModelField":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.fields.ModelField","kind":"Gdef","module_public":false},"MongoDsn":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.networks.AnyUrl"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.networks.MongoDsn","name":"MongoDsn","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.networks.MongoDsn","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic.v1.networks","mro":["pydantic.v1.networks.MongoDsn","pydantic.v1.networks.AnyUrl","builtins.str","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","allowed_schemes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.networks.MongoDsn.allowed_schemes","name":"allowed_schemes","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"get_default_parts":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["parts"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"pydantic.v1.networks.MongoDsn.get_default_parts","name":"get_default_parts","original_first_arg":"parts","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["parts"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_default_parts of MongoDsn","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_staticmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.networks.MongoDsn.get_default_parts","name":"get_default_parts","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["parts"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_default_parts of MongoDsn","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.networks.MongoDsn.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.networks.MongoDsn","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"MultiHostDsn":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.networks.AnyUrl"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.networks.MultiHostDsn","name":"MultiHostDsn","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.networks.MultiHostDsn","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic.v1.networks","mro":["pydantic.v1.networks.MultiHostDsn","pydantic.v1.networks.AnyUrl","builtins.str","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,5,4],"arg_names":["self","args","hosts","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.networks.MultiHostDsn.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,5,4],"arg_names":["self","args","hosts","kwargs"],"arg_types":["pydantic.v1.networks.MultiHostDsn",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.HostParts"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of MultiHostDsn","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic.v1.networks.MultiHostDsn.__slots__","name":"__slots__","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":5},"type_of_any":7}}},"_build_url":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["cls","m","url","parts"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.networks.MultiHostDsn._build_url","name":"_build_url","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["cls","m","url","parts"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.MultiHostDsn"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Match"},"builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_build_url of MultiHostDsn","ret_type":"pydantic.v1.networks.MultiHostDsn","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.networks.MultiHostDsn._build_url","name":"_build_url","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["cls","m","url","parts"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.MultiHostDsn"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Match"},"builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_build_url of MultiHostDsn","ret_type":"pydantic.v1.networks.MultiHostDsn","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"_match_url":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["url"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"pydantic.v1.networks.MultiHostDsn._match_url","name":"_match_url","original_first_arg":"url","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["url"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_match_url of MultiHostDsn","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Match"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_staticmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.networks.MultiHostDsn._match_url","name":"_match_url","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["url"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_match_url of MultiHostDsn","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Match"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"hosts":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.networks.MultiHostDsn.hosts","name":"hosts","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.HostParts"}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"validate_parts":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["cls","parts","validate_port"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.networks.MultiHostDsn.validate_parts","name":"validate_parts","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["cls","parts","validate_port"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.MultiHostDsn"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate_parts of MultiHostDsn","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.networks.MultiHostDsn.validate_parts","name":"validate_parts","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["cls","parts","validate_port"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.MultiHostDsn"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate_parts of MultiHostDsn","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.networks.MultiHostDsn.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.networks.MultiHostDsn","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"NameEmail":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.utils.Representation"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.networks.NameEmail","name":"NameEmail","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.networks.NameEmail","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.networks","mro":["pydantic.v1.networks.NameEmail","pydantic.v1.utils.Representation","builtins.object"],"names":{".class":"SymbolTable","__eq__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.networks.NameEmail.__eq__","name":"__eq__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["pydantic.v1.networks.NameEmail",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__eq__ of NameEmail","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__get_validators__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.networks.NameEmail.__get_validators__","name":"__get_validators__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.NameEmail"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of NameEmail","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.networks.NameEmail.__get_validators__","name":"__get_validators__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.NameEmail"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of NameEmail","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","name","email"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.networks.NameEmail.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","name","email"],"arg_types":["pydantic.v1.networks.NameEmail","builtins.str","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of NameEmail","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__modify_schema__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","field_schema"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.networks.NameEmail.__modify_schema__","name":"__modify_schema__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field_schema"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.NameEmail"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__modify_schema__ of NameEmail","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.networks.NameEmail.__modify_schema__","name":"__modify_schema__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field_schema"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.NameEmail"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__modify_schema__ of NameEmail","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic.v1.networks.NameEmail.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"__str__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.networks.NameEmail.__str__","name":"__str__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["pydantic.v1.networks.NameEmail"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__str__ of NameEmail","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"email":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.networks.NameEmail.email","name":"email","setter_type":null,"type":"builtins.str"}},"name":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.networks.NameEmail.name","name":"name","setter_type":null,"type":"builtins.str"}},"validate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.networks.NameEmail.validate","name":"validate","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","value"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.NameEmail"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate of NameEmail","ret_type":"pydantic.v1.networks.NameEmail","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.networks.NameEmail.validate","name":"validate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","value"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.networks.NameEmail"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate of NameEmail","ret_type":"pydantic.v1.networks.NameEmail","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.networks.NameEmail.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.networks.NameEmail","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"NetworkType":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic.v1.networks.NetworkType","line":70,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["builtins.str","builtins.bytes","builtins.int",{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str","builtins.bytes","builtins.int"],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str","builtins.int"],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":false}}},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef","module_public":false},"Parts":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.networks.Parts","name":"Parts","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.networks.Parts","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.networks","mro":["pydantic.v1.networks.Parts","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["scheme","builtins.str"],["user",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],["password",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],["ipv4",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],["ipv6",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],["domain",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],["port",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],["path",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],["query",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],["fragment",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}]],"readonly_keys":[],"required_keys":[]}}},"Pattern":{".class":"SymbolTableNode","cross_ref":"re.Pattern","kind":"Gdef","module_public":false},"PostgresDsn":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.networks.MultiHostDsn"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.networks.PostgresDsn","name":"PostgresDsn","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.networks.PostgresDsn","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic.v1.networks","mro":["pydantic.v1.networks.PostgresDsn","pydantic.v1.networks.MultiHostDsn","pydantic.v1.networks.AnyUrl","builtins.str","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic.v1.networks.PostgresDsn.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"allowed_schemes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.networks.PostgresDsn.allowed_schemes","name":"allowed_schemes","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"user_required":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.networks.PostgresDsn.user_required","name":"user_required","setter_type":null,"type":"builtins.bool"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.networks.PostgresDsn.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.networks.PostgresDsn","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"RedisDsn":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.networks.AnyUrl"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.networks.RedisDsn","name":"RedisDsn","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.networks.RedisDsn","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic.v1.networks","mro":["pydantic.v1.networks.RedisDsn","pydantic.v1.networks.AnyUrl","builtins.str","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic.v1.networks.RedisDsn.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":[],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"allowed_schemes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.networks.RedisDsn.allowed_schemes","name":"allowed_schemes","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"get_default_parts":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["parts"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"pydantic.v1.networks.RedisDsn.get_default_parts","name":"get_default_parts","original_first_arg":"parts","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["parts"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_default_parts of RedisDsn","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_staticmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.networks.RedisDsn.get_default_parts","name":"get_default_parts","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["parts"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_default_parts of RedisDsn","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.networks.Parts"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"host_required":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.networks.RedisDsn.host_required","name":"host_required","setter_type":null,"type":"builtins.bool"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.networks.RedisDsn.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.networks.RedisDsn","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Representation":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.Representation","kind":"Gdef","module_public":false},"Set":{".class":"SymbolTableNode","cross_ref":"typing.Set","kind":"Gdef","module_public":false},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef","module_public":false},"Tuple":{".class":"SymbolTableNode","cross_ref":"typing.Tuple","kind":"Gdef","module_public":false},"Type":{".class":"SymbolTableNode","cross_ref":"typing.Type","kind":"Gdef","module_public":false},"TypedDict":{".class":"SymbolTableNode","cross_ref":"typing.TypedDict","kind":"Gdef","module_public":false},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef","module_public":false},"_BaseAddress":{".class":"SymbolTableNode","cross_ref":"ipaddress._BaseAddress","kind":"Gdef","module_public":false},"_BaseNetwork":{".class":"SymbolTableNode","cross_ref":"ipaddress._BaseNetwork","kind":"Gdef","module_public":false},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.networks.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.networks.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.networks.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.networks.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.networks.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.networks.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.networks.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_ascii_domain_regex_cache":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.networks._ascii_domain_regex_cache","name":"_ascii_domain_regex_cache","setter_type":null,"type":{".class":"NoneType"}}},"_fragment_regex":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.networks._fragment_regex","name":"_fragment_regex","setter_type":null,"type":"builtins.str"}},"_host_regex":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.networks._host_regex","name":"_host_regex","setter_type":null,"type":"builtins.str"}},"_host_regex_cache":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.networks._host_regex_cache","name":"_host_regex_cache","setter_type":null,"type":{".class":"NoneType"}}},"_int_domain_regex_cache":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.networks._int_domain_regex_cache","name":"_int_domain_regex_cache","setter_type":null,"type":{".class":"NoneType"}}},"_multi_host_url_regex_cache":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.networks._multi_host_url_regex_cache","name":"_multi_host_url_regex_cache","setter_type":null,"type":{".class":"NoneType"}}},"_path_regex":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.networks._path_regex","name":"_path_regex","setter_type":null,"type":"builtins.str"}},"_query_regex":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.networks._query_regex","name":"_query_regex","setter_type":null,"type":"builtins.str"}},"_scheme_regex":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.networks._scheme_regex","name":"_scheme_regex","setter_type":null,"type":"builtins.str"}},"_url_regex_cache":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.networks._url_regex_cache","name":"_url_regex_cache","setter_type":null,"type":{".class":"NoneType"}}},"_user_info_regex":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.networks._user_info_regex","name":"_user_info_regex","setter_type":null,"type":"builtins.str"}},"ascii_domain_regex":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.networks.ascii_domain_regex","name":"ascii_domain_regex","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ascii_domain_regex","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"cast":{".class":"SymbolTableNode","cross_ref":"typing.cast","kind":"Gdef","module_public":false},"constr_length_validator":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.validators.constr_length_validator","kind":"Gdef","module_public":false},"email_validator":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"pydantic.v1.networks.email_validator","name":"email_validator","setter_type":null,"type":{".class":"AnyType","missing_import_name":"pydantic.v1.networks.email_validator","source_any":null,"type_of_any":3}}},"errors":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors","kind":"Gdef","module_public":false},"host_regex":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.networks.host_regex","name":"host_regex","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"host_regex","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"import_email_validator":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.networks.import_email_validator","name":"import_email_validator","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"import_email_validator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"int_domain_regex":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.networks.int_domain_regex","name":"int_domain_regex","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"int_domain_regex","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"multi_host_url_regex":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.networks.multi_host_url_regex","name":"multi_host_url_regex","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"multi_host_url_regex","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"no_type_check":{".class":"SymbolTableNode","cross_ref":"typing.no_type_check","kind":"Gdef","module_public":false},"pretty_email_regex":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.networks.pretty_email_regex","name":"pretty_email_regex","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef","module_public":false},"str_validator":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.validators.str_validator","kind":"Gdef","module_public":false},"stricturl":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5],"arg_names":["strip_whitespace","min_length","max_length","tld_required","host_required","allowed_schemes"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.networks.stricturl","name":"stricturl","original_first_arg":"strip_whitespace","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5],"arg_names":["strip_whitespace","min_length","max_length","tld_required","host_required","allowed_schemes"],"arg_types":["builtins.bool","builtins.int","builtins.int","builtins.bool","builtins.bool",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Collection"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"stricturl","ret_type":{".class":"TypeType","item":"pydantic.v1.networks.AnyUrl"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"update_not_none":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.update_not_none","kind":"Gdef","module_public":false},"url_regex":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.networks.url_regex","name":"url_regex","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"url_regex","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"validate_email":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["value"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.networks.validate_email","name":"validate_email","original_first_arg":"value","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["value"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate_email","ret_type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/networks.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/networks.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/networks.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..b0d0ef581bcc39d3d5503f13e1313d280e5d039d --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/networks.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[30,31,32,38,39,40,30,1,2,12,36,1,1,1,1,35],"dep_prios":[10,5,5,25,25,25,20,10,5,5,25,5,30,30,30,25],"dependencies":["pydantic.v1.errors","pydantic.v1.utils","pydantic.v1.validators","pydantic.v1.config","pydantic.v1.fields","pydantic.v1.typing","pydantic.v1","re","ipaddress","typing","typing_extensions","builtins","_frozen_importlib","abc","enum"],"hash":"ac587133cb640e4c9a52aa2aadcaf43d1fe34dd9","id":"pydantic.v1.networks","ignore_all":true,"interface_hash":"789351a01f4b5239b27d1b4bb0d4e0d7ffee78f0","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/networks.py","plugin_data":null,"size":22124,"suppressed":["email_validator"],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/parse.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/parse.data.json new file mode 100644 index 0000000000000000000000000000000000000000..d274d1ff7ffce6866492ab6b4b39a338bacfe11e --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/parse.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic.v1.parse","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"Enum":{".class":"SymbolTableNode","cross_ref":"enum.Enum","kind":"Gdef"},"Path":{".class":"SymbolTableNode","cross_ref":"pathlib.Path","kind":"Gdef"},"Protocol":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.str","enum.Enum"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.parse.Protocol","name":"Protocol","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_enum"],"fullname":"pydantic.v1.parse.Protocol","has_param_spec_type":false,"metaclass_type":"enum.EnumMeta","metadata":{},"module_name":"pydantic.v1.parse","mro":["pydantic.v1.parse.Protocol","builtins.str","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","enum.Enum","builtins.object"],"names":{".class":"SymbolTable","json":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.parse.Protocol.json","name":"json","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.str","value":"json"},"type_ref":"builtins.str"}}},"pickle":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.parse.Protocol.pickle","name":"pickle","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.str","value":"pickle"},"type_ref":"builtins.str"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.parse.Protocol.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.parse.Protocol","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"StrBytes":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.StrBytes","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.parse.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.parse.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.parse.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.parse.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.parse.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.parse.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"json":{".class":"SymbolTableNode","cross_ref":"json","kind":"Gdef"},"load_file":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5,5],"arg_names":["path","content_type","encoding","proto","allow_pickle","json_loads"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.parse.load_file","name":"load_file","original_first_arg":"path","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5,5],"arg_names":["path","content_type","encoding","proto","allow_pickle","json_loads"],"arg_types":[{".class":"UnionType","items":["builtins.str","pathlib.Path"],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str",{".class":"UnionType","items":["pydantic.v1.parse.Protocol",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"load_file","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"load_str_bytes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5,5],"arg_names":["b","content_type","encoding","proto","allow_pickle","json_loads"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.parse.load_str_bytes","name":"load_str_bytes","original_first_arg":"b","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5,5],"arg_names":["b","content_type","encoding","proto","allow_pickle","json_loads"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.StrBytes"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str",{".class":"UnionType","items":["pydantic.v1.parse.Protocol",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"load_str_bytes","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"pickle":{".class":"SymbolTableNode","cross_ref":"pickle","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/parse.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/parse.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/parse.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..d83b47c19e07cb249cae78f8b88355493d5950f4 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/parse.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[7,1,2,3,4,5,1,1,1,1,1],"dep_prios":[5,10,10,5,5,5,5,30,30,30,30],"dependencies":["pydantic.v1.types","json","pickle","enum","pathlib","typing","builtins","_frozen_importlib","abc","json.decoder","os"],"hash":"0b1a4bdfddf6460d8281dfb915fbba2dfcc42e53","id":"pydantic.v1.parse","ignore_all":true,"interface_hash":"460d3c5c9a902854460d07b9d32661e407955b81","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/parse.py","plugin_data":null,"size":1821,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/schema.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/schema.data.json new file mode 100644 index 0000000000000000000000000000000000000000..31fc943978ec2b5f39bf87bb0a28ad0a34cea59d --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/schema.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic.v1.schema","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Annotated":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Annotated","kind":"Gdef"},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"AnyUrl":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.networks.AnyUrl","kind":"Gdef"},"BaseModel":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.main.BaseModel","kind":"Gdef"},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"ConstrainedDecimal":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.ConstrainedDecimal","kind":"Gdef"},"ConstrainedFloat":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.ConstrainedFloat","kind":"Gdef"},"ConstrainedFrozenSet":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.ConstrainedFrozenSet","kind":"Gdef"},"ConstrainedInt":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.ConstrainedInt","kind":"Gdef"},"ConstrainedList":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.ConstrainedList","kind":"Gdef"},"ConstrainedSet":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.ConstrainedSet","kind":"Gdef"},"ConstrainedStr":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.ConstrainedStr","kind":"Gdef"},"Dataclass":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.dataclasses.Dataclass","kind":"Gdef"},"Decimal":{".class":"SymbolTableNode","cross_ref":"decimal.Decimal","kind":"Gdef"},"Dict":{".class":"SymbolTableNode","cross_ref":"typing.Dict","kind":"Gdef"},"EmailStr":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.networks.EmailStr","kind":"Gdef"},"Enum":{".class":"SymbolTableNode","cross_ref":"enum.Enum","kind":"Gdef"},"FieldInfo":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.fields.FieldInfo","kind":"Gdef"},"ForwardRef":{".class":"SymbolTableNode","cross_ref":"typing.ForwardRef","kind":"Gdef"},"FrozenSet":{".class":"SymbolTableNode","cross_ref":"typing.FrozenSet","kind":"Gdef"},"Generic":{".class":"SymbolTableNode","cross_ref":"typing.Generic","kind":"Gdef"},"IPv4Address":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv4Address","kind":"Gdef"},"IPv4Interface":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv4Interface","kind":"Gdef"},"IPv4Network":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv4Network","kind":"Gdef"},"IPv6Address":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv6Address","kind":"Gdef"},"IPv6Interface":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv6Interface","kind":"Gdef"},"IPv6Network":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv6Network","kind":"Gdef"},"Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef"},"List":{".class":"SymbolTableNode","cross_ref":"typing.List","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Literal","kind":"Gdef"},"MAPPING_LIKE_SHAPES":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.fields.MAPPING_LIKE_SHAPES","kind":"Gdef"},"ModelField":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.fields.ModelField","kind":"Gdef"},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef"},"Path":{".class":"SymbolTableNode","cross_ref":"pathlib.Path","kind":"Gdef"},"Pattern":{".class":"SymbolTableNode","cross_ref":"re.Pattern","kind":"Gdef"},"ROOT_KEY":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.ROOT_KEY","kind":"Gdef"},"SHAPE_DEQUE":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.fields.SHAPE_DEQUE","kind":"Gdef"},"SHAPE_FROZENSET":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.fields.SHAPE_FROZENSET","kind":"Gdef"},"SHAPE_GENERIC":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.fields.SHAPE_GENERIC","kind":"Gdef"},"SHAPE_ITERABLE":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.fields.SHAPE_ITERABLE","kind":"Gdef"},"SHAPE_LIST":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.fields.SHAPE_LIST","kind":"Gdef"},"SHAPE_SEQUENCE":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.fields.SHAPE_SEQUENCE","kind":"Gdef"},"SHAPE_SET":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.fields.SHAPE_SET","kind":"Gdef"},"SHAPE_SINGLETON":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.fields.SHAPE_SINGLETON","kind":"Gdef"},"SHAPE_TUPLE":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.fields.SHAPE_TUPLE","kind":"Gdef"},"SHAPE_TUPLE_ELLIPSIS":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.fields.SHAPE_TUPLE_ELLIPSIS","kind":"Gdef"},"SecretBytes":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.SecretBytes","kind":"Gdef"},"SecretStr":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.SecretStr","kind":"Gdef"},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef"},"Set":{".class":"SymbolTableNode","cross_ref":"typing.Set","kind":"Gdef"},"SkipField":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.Exception"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.schema.SkipField","name":"SkipField","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.schema.SkipField","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.schema","mro":["pydantic.v1.schema.SkipField","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","message"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.schema.SkipField.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","message"],"arg_types":["pydantic.v1.schema.SkipField","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of SkipField","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"message":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.schema.SkipField.message","name":"message","setter_type":null,"type":"builtins.str"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.schema.SkipField.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.schema.SkipField","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"StrictBytes":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.StrictBytes","kind":"Gdef"},"StrictStr":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.StrictStr","kind":"Gdef"},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"Tuple":{".class":"SymbolTableNode","cross_ref":"typing.Tuple","kind":"Gdef"},"Type":{".class":"SymbolTableNode","cross_ref":"typing.Type","kind":"Gdef"},"TypeModelOrEnum":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic.v1.schema.TypeModelOrEnum","line":92,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"TypeType","item":"pydantic.v1.main.BaseModel"},{".class":"TypeType","item":"enum.Enum"}],"uses_pep604_syntax":false}}},"TypeModelSet":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic.v1.schema.TypeModelSet","line":93,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.schema.TypeModelOrEnum"}],"extra_attrs":null,"type_ref":"builtins.set"}}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef"},"UUID":{".class":"SymbolTableNode","cross_ref":"uuid.UUID","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.schema.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.schema.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.schema.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.schema.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.schema.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.schema.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_apply_modify_schema":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["modify_schema","field","field_schema"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.schema._apply_modify_schema","name":"_apply_modify_schema","original_first_arg":"modify_schema","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["modify_schema","field","field_schema"],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"UnionType","items":["pydantic.v1.fields.ModelField",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_apply_modify_schema","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_map_types_constraint":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic.v1.schema._map_types_constraint","name":"_map_types_constraint","setter_type":null,"type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":"builtins.type","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_numeric_types_attrs":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic.v1.schema._numeric_types_attrs","name":"_numeric_types_attrs","setter_type":null,"type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.str",{".class":"UnionType","items":["builtins.type",{".class":"Instance","args":["builtins.type"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":false},"builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"builtins.tuple"}}},"_str_types_attrs":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic.v1.schema._str_types_attrs","name":"_str_types_attrs","setter_type":null,"type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.str",{".class":"UnionType","items":["builtins.type",{".class":"Instance","args":["builtins.type"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":false},"builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"builtins.tuple"}}},"add_field_type_to_schema":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["field_type","schema_"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.schema.add_field_type_to_schema","name":"add_field_type_to_schema","original_first_arg":"field_type","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["field_type","schema_"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add_field_type_to_schema","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"all_literal_values":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.all_literal_values","kind":"Gdef"},"cast":{".class":"SymbolTableNode","cross_ref":"typing.cast","kind":"Gdef"},"conbytes":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.conbytes","kind":"Gdef"},"condecimal":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.condecimal","kind":"Gdef"},"confloat":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.confloat","kind":"Gdef"},"confrozenset":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.confrozenset","kind":"Gdef"},"conint":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.conint","kind":"Gdef"},"conlist":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.conlist","kind":"Gdef"},"conset":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.conset","kind":"Gdef"},"constr":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.constr","kind":"Gdef"},"date":{".class":"SymbolTableNode","cross_ref":"datetime.date","kind":"Gdef"},"datetime":{".class":"SymbolTableNode","cross_ref":"datetime.datetime","kind":"Gdef"},"default_prefix":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.schema.default_prefix","name":"default_prefix","setter_type":null,"type":"builtins.str"}},"default_ref_template":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.schema.default_ref_template","name":"default_ref_template","setter_type":null,"type":"builtins.str"}},"defaultdict":{".class":"SymbolTableNode","cross_ref":"collections.defaultdict","kind":"Gdef"},"encode_default":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["dft"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.schema.encode_default","name":"encode_default","original_first_arg":"dft","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dft"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"encode_default","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"enum_process_schema":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5],"arg_names":["enum","field"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.schema.enum_process_schema","name":"enum_process_schema","original_first_arg":"enum","type":{".class":"CallableType","arg_kinds":[0,5],"arg_names":["enum","field"],"arg_types":[{".class":"TypeType","item":"enum.Enum"},{".class":"UnionType","items":["pydantic.v1.fields.ModelField",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"enum_process_schema","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"field_class_to_schema":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic.v1.schema.field_class_to_schema","name":"field_class_to_schema","setter_type":null,"type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"builtins.tuple"}}},"field_schema":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,3,5,5,5],"arg_names":["field","by_alias","model_name_map","ref_prefix","ref_template","known_models"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.schema.field_schema","name":"field_schema","original_first_arg":"field","type":{".class":"CallableType","arg_kinds":[0,5,3,5,5,5],"arg_names":["field","by_alias","model_name_map","ref_prefix","ref_template","known_models"],"arg_types":["pydantic.v1.fields.ModelField","builtins.bool",{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.schema.TypeModelOrEnum"},"builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.schema.TypeModelSet"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"field_schema","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"field_singleton_schema":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,3,3,5,5,3],"arg_names":["field","by_alias","model_name_map","ref_template","schema_overrides","ref_prefix","known_models"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.schema.field_singleton_schema","name":"field_singleton_schema","original_first_arg":"field","type":{".class":"CallableType","arg_kinds":[0,3,3,3,5,5,3],"arg_names":["field","by_alias","model_name_map","ref_template","schema_overrides","ref_prefix","known_models"],"arg_types":["pydantic.v1.fields.ModelField","builtins.bool",{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.schema.TypeModelOrEnum"},"builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.str","builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.schema.TypeModelSet"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"field_singleton_schema","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"field_singleton_sub_fields_schema":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,3,3,5,5,3],"arg_names":["field","by_alias","model_name_map","ref_template","schema_overrides","ref_prefix","known_models"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.schema.field_singleton_sub_fields_schema","name":"field_singleton_sub_fields_schema","original_first_arg":"field","type":{".class":"CallableType","arg_kinds":[0,3,3,3,5,5,3],"arg_names":["field","by_alias","model_name_map","ref_template","schema_overrides","ref_prefix","known_models"],"arg_types":["pydantic.v1.fields.ModelField","builtins.bool",{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.schema.TypeModelOrEnum"},"builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.str","builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.schema.TypeModelSet"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"field_singleton_sub_fields_schema","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"field_type_schema":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,3,3,5,5,3],"arg_names":["field","by_alias","model_name_map","ref_template","schema_overrides","ref_prefix","known_models"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.schema.field_type_schema","name":"field_type_schema","original_first_arg":"field","type":{".class":"CallableType","arg_kinds":[0,3,3,3,5,5,3],"arg_names":["field","by_alias","model_name_map","ref_template","schema_overrides","ref_prefix","known_models"],"arg_types":["pydantic.v1.fields.ModelField","builtins.bool",{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.schema.TypeModelOrEnum"},"builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.str","builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.schema.TypeModelSet"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"field_type_schema","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_annotation_from_field_info":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["annotation","field_info","field_name","validate_assignment"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.schema.get_annotation_from_field_info","name":"get_annotation_from_field_info","original_first_arg":"annotation","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["annotation","field_info","field_name","validate_assignment"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"pydantic.v1.fields.FieldInfo","builtins.str","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_annotation_from_field_info","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_annotation_with_constraints":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["annotation","field_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.schema.get_annotation_with_constraints","name":"get_annotation_with_constraints","original_first_arg":"annotation","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["annotation","field_info"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"pydantic.v1.fields.FieldInfo"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_annotation_with_constraints","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_args":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.get_args","kind":"Gdef"},"get_field_info_schema":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["field","schema_overrides"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.schema.get_field_info_schema","name":"get_field_info_schema","original_first_arg":"field","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["field","schema_overrides"],"arg_types":["pydantic.v1.fields.ModelField","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_field_info_schema","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.bool"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_field_schema_validations":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["field"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.schema.get_field_schema_validations","name":"get_field_schema_validations","original_first_arg":"field","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["field"],"arg_types":["pydantic.v1.fields.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_field_schema_validations","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_flat_models_from_field":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["field","known_models"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.schema.get_flat_models_from_field","name":"get_flat_models_from_field","original_first_arg":"field","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["field","known_models"],"arg_types":["pydantic.v1.fields.ModelField",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.schema.TypeModelSet"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_flat_models_from_field","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.schema.TypeModelSet"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_flat_models_from_fields":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["fields","known_models"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.schema.get_flat_models_from_fields","name":"get_flat_models_from_fields","original_first_arg":"fields","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["fields","known_models"],"arg_types":[{".class":"Instance","args":["pydantic.v1.fields.ModelField"],"extra_attrs":null,"type_ref":"typing.Sequence"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.schema.TypeModelSet"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_flat_models_from_fields","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.schema.TypeModelSet"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_flat_models_from_model":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["model","known_models"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.schema.get_flat_models_from_model","name":"get_flat_models_from_model","original_first_arg":"model","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["model","known_models"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.main.BaseModel"},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.schema.TypeModelSet"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_flat_models_from_model","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.schema.TypeModelSet"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_flat_models_from_models":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["models"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.schema.get_flat_models_from_models","name":"get_flat_models_from_models","original_first_arg":"models","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["models"],"arg_types":[{".class":"Instance","args":[{".class":"TypeType","item":"pydantic.v1.main.BaseModel"}],"extra_attrs":null,"type_ref":"typing.Sequence"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_flat_models_from_models","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.schema.TypeModelSet"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_long_model_name":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["model"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.schema.get_long_model_name","name":"get_long_model_name","original_first_arg":"model","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["model"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.schema.TypeModelOrEnum"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_long_model_name","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_model":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.get_model","kind":"Gdef"},"get_model_name_map":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["unique_models"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.schema.get_model_name_map","name":"get_model_name_map","original_first_arg":"unique_models","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["unique_models"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.schema.TypeModelSet"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_model_name_map","ret_type":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.schema.TypeModelOrEnum"},"builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_origin":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.get_origin","kind":"Gdef"},"get_schema_ref":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["name","ref_prefix","ref_template","schema_overrides"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.schema.get_schema_ref","name":"get_schema_ref","original_first_arg":"name","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["name","ref_prefix","ref_template","schema_overrides"],"arg_types":["builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_schema_ref","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_sub_types":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.get_sub_types","kind":"Gdef"},"is_callable_type":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.is_callable_type","kind":"Gdef"},"is_dataclass":{".class":"SymbolTableNode","cross_ref":"dataclasses.is_dataclass","kind":"Gdef"},"is_literal_type":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.is_literal_type","kind":"Gdef"},"is_namedtuple":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.is_namedtuple","kind":"Gdef"},"is_none_type":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.is_none_type","kind":"Gdef"},"is_union":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.is_union","kind":"Gdef"},"json_scheme":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.schema.json_scheme","name":"json_scheme","setter_type":null,"type":{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"lenient_issubclass":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.lenient_issubclass","kind":"Gdef"},"model_process_schema":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,3,5,5,5,5],"arg_names":["model","by_alias","model_name_map","ref_prefix","ref_template","known_models","field"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.schema.model_process_schema","name":"model_process_schema","original_first_arg":"model","type":{".class":"CallableType","arg_kinds":[0,5,3,5,5,5,5],"arg_names":["model","by_alias","model_name_map","ref_prefix","ref_template","known_models","field"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.schema.TypeModelOrEnum"},"builtins.bool",{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.schema.TypeModelOrEnum"},"builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.schema.TypeModelSet"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["pydantic.v1.fields.ModelField",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"model_process_schema","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"model_schema":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["model","by_alias","ref_prefix","ref_template"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.schema.model_schema","name":"model_schema","original_first_arg":"model","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["model","by_alias","ref_prefix","ref_template"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeType","item":"pydantic.v1.main.BaseModel"},{".class":"TypeType","item":"pydantic.v1.dataclasses.Dataclass"}],"uses_pep604_syntax":false},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"model_schema","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"model_type_schema":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,3,3,3,5,3],"arg_names":["model","by_alias","model_name_map","ref_template","ref_prefix","known_models"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.schema.model_type_schema","name":"model_type_schema","original_first_arg":"model","type":{".class":"CallableType","arg_kinds":[0,3,3,3,5,3],"arg_names":["model","by_alias","model_name_map","ref_template","ref_prefix","known_models"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.main.BaseModel"},"builtins.bool",{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.schema.TypeModelOrEnum"},"builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},"builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.schema.TypeModelSet"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"model_type_schema","ret_type":{".class":"TupleType","implicit":false,"items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"multitypes_literal_field_for_schema":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["values","field"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.schema.multitypes_literal_field_for_schema","name":"multitypes_literal_field_for_schema","original_first_arg":"values","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["values","field"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"},"pydantic.v1.fields.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"multitypes_literal_field_for_schema","ret_type":"pydantic.v1.fields.ModelField","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"normalize_name":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.schema.normalize_name","name":"normalize_name","original_first_arg":"name","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["name"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"normalize_name","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"numeric_types":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.schema.numeric_types","name":"numeric_types","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":[{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[1],"arg_names":[null],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.ConvertibleToInt"}],"fallback":"builtins.type","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":"int","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,"base"],"arg_types":[{".class":"UnionType","items":["builtins.str","builtins.bytes","builtins.bytearray"],"uses_pep604_syntax":false},"typing.SupportsIndex"],"fallback":"builtins.type","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":"int","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]},{".class":"CallableType","arg_kinds":[1],"arg_names":[null],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"_typeshed.ConvertibleToFloat"}],"fallback":"builtins.type","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":"float","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[1,1],"arg_names":["value","context"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"decimal._DecimalNew"},{".class":"UnionType","items":["decimal.Context",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.type","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":"Decimal","ret_type":"decimal.Decimal","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"pydantic_encoder":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.json.pydantic_encoder","kind":"Gdef"},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef"},"schema":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5,5],"arg_names":["models","by_alias","title","description","ref_prefix","ref_template"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.schema.schema","name":"schema","original_first_arg":"models","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5,5],"arg_names":["models","by_alias","title","description","ref_prefix","ref_template"],"arg_types":[{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"TypeType","item":"pydantic.v1.main.BaseModel"},{".class":"TypeType","item":"pydantic.v1.dataclasses.Dataclass"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"typing.Sequence"},"builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"schema","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"time":{".class":"SymbolTableNode","cross_ref":"datetime.time","kind":"Gdef"},"timedelta":{".class":"SymbolTableNode","cross_ref":"datetime.timedelta","kind":"Gdef"},"warnings":{".class":"SymbolTableNode","cross_ref":"warnings","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/schema.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/schema.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/schema.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..8b63ecf422e39eb84e8e06f23052dc7ac5a2d281 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/schema.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[34,49,50,51,72,83,86,87,1,2,3,4,5,6,7,8,9,10,30,32,1,1,1,1,1],"dep_prios":[5,5,5,5,5,5,25,25,10,10,5,5,5,5,5,5,5,5,5,5,5,30,30,30,30],"dependencies":["pydantic.v1.fields","pydantic.v1.json","pydantic.v1.networks","pydantic.v1.types","pydantic.v1.typing","pydantic.v1.utils","pydantic.v1.dataclasses","pydantic.v1.main","re","warnings","collections","dataclasses","datetime","decimal","enum","ipaddress","pathlib","typing","uuid","typing_extensions","builtins","_frozen_importlib","_typeshed","abc","os"],"hash":"0799a57e5d15899fc450de7a1290379d94cdc9db","id":"pydantic.v1.schema","ignore_all":true,"interface_hash":"62b8f936df518295caf87be704543e7bf3262548","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/schema.py","plugin_data":null,"size":47801,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/tools.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/tools.data.json new file mode 100644 index 0000000000000000000000000000000000000000..136e5f191debded326f2f1ddc71ab3930a35bb92 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/tools.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic.v1.tools","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_public":false},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef","module_public":false},"DictStrAny":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.DictStrAny","kind":"Gdef","module_public":false},"NameFactory":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic.v1.tools.NameFactory","line":12,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["builtins.str",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"uses_pep604_syntax":false}}},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef","module_public":false},"Path":{".class":"SymbolTableNode","cross_ref":"pathlib.Path","kind":"Gdef","module_public":false},"Protocol":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.parse.Protocol","kind":"Gdef","module_public":false},"StrBytes":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.StrBytes","kind":"Gdef","module_public":false},"T":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.tools.T","name":"T","upper_bound":"builtins.object","values":[],"variance":0}},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef","module_public":false},"Type":{".class":"SymbolTableNode","cross_ref":"typing.Type","kind":"Gdef","module_public":false},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_public":false},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef","module_public":false},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.tools.__all__","name":"__all__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.tools.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.tools.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.tools.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.tools.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.tools.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.tools.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_generate_parsing_type_name":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["type_"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.tools._generate_parsing_type_name","name":"_generate_parsing_type_name","original_first_arg":"type_","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["type_"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_generate_parsing_type_name","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_get_parsing_type":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5],"arg_names":["type_","type_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated"],"fullname":"pydantic.v1.tools._get_parsing_type","name":"_get_parsing_type","original_first_arg":"type_","type":{".class":"CallableType","arg_kinds":[0,5],"arg_names":["type_","type_name"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.tools.NameFactory"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_parsing_type","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.tools._get_parsing_type","name":"_get_parsing_type","setter_type":null,"type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_of_any":7}],"extra_attrs":null,"type_ref":"functools._lru_cache_wrapper"}}}},"display_as_type":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.display_as_type","kind":"Gdef","module_public":false},"json":{".class":"SymbolTableNode","cross_ref":"json","kind":"Gdef","module_public":false},"load_file":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.parse.load_file","kind":"Gdef","module_public":false},"load_str_bytes":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.parse.load_str_bytes","kind":"Gdef","module_public":false},"lru_cache":{".class":"SymbolTableNode","cross_ref":"functools.lru_cache","kind":"Gdef","module_public":false},"parse_file_as":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5,5],"arg_names":["type_","path","content_type","encoding","proto","allow_pickle","json_loads","type_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.tools.parse_file_as","name":"parse_file_as","original_first_arg":"type_","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5],"arg_names":["type_","path","content_type","encoding","proto","allow_pickle","json_loads","type_name"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.tools.T","id":-1,"name":"T","namespace":"pydantic.v1.tools.parse_file_as","upper_bound":"builtins.object","values":[],"variance":0}},{".class":"UnionType","items":["builtins.str","pathlib.Path"],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str",{".class":"UnionType","items":["pydantic.v1.parse.Protocol",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.tools.NameFactory"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parse_file_as","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.tools.T","id":-1,"name":"T","namespace":"pydantic.v1.tools.parse_file_as","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.tools.T","id":-1,"name":"T","namespace":"pydantic.v1.tools.parse_file_as","upper_bound":"builtins.object","values":[],"variance":0}]}}},"parse_obj_as":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5],"arg_names":["type_","obj","type_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.tools.parse_obj_as","name":"parse_obj_as","original_first_arg":"type_","type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["type_","obj","type_name"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.tools.T","id":-1,"name":"T","namespace":"pydantic.v1.tools.parse_obj_as","upper_bound":"builtins.object","values":[],"variance":0}},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.tools.NameFactory"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parse_obj_as","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.tools.T","id":-1,"name":"T","namespace":"pydantic.v1.tools.parse_obj_as","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.tools.T","id":-1,"name":"T","namespace":"pydantic.v1.tools.parse_obj_as","upper_bound":"builtins.object","values":[],"variance":0}]}}},"parse_raw_as":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5,5,5,5,5,5],"arg_names":["type_","b","content_type","encoding","proto","allow_pickle","json_loads","type_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.tools.parse_raw_as","name":"parse_raw_as","original_first_arg":"type_","type":{".class":"CallableType","arg_kinds":[0,0,5,5,5,5,5,5],"arg_names":["type_","b","content_type","encoding","proto","allow_pickle","json_loads","type_name"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.tools.T","id":-1,"name":"T","namespace":"pydantic.v1.tools.parse_raw_as","upper_bound":"builtins.object","values":[],"variance":0}},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.StrBytes"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.str",{".class":"UnionType","items":["pydantic.v1.parse.Protocol",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.tools.NameFactory"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parse_raw_as","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.tools.T","id":-1,"name":"T","namespace":"pydantic.v1.tools.parse_raw_as","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.tools.T","id":-1,"name":"T","namespace":"pydantic.v1.tools.parse_raw_as","upper_bound":"builtins.object","values":[],"variance":0}]}}},"schema_json_of":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,4],"arg_names":["type_","title","schema_json_kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.tools.schema_json_of","name":"schema_json_of","original_first_arg":"type_","type":{".class":"CallableType","arg_kinds":[0,5,4],"arg_names":["type_","title","schema_json_kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.tools.NameFactory"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"schema_json_of","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"schema_of":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,4],"arg_names":["type_","title","schema_kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.tools.schema_of","name":"schema_of","original_first_arg":"type_","type":{".class":"CallableType","arg_kinds":[0,5,4],"arg_names":["type_","title","schema_kwargs"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.tools.NameFactory"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"schema_of","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.DictStrAny"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/tools.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/tools.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/tools.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..37591d6e5b8c5b178ce58810cfb0458657b9a5ad --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/tools.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[6,7,8,1,2,3,4,1,1,1,1,1,1],"dep_prios":[5,5,5,10,5,5,5,5,30,30,30,30,30],"dependencies":["pydantic.v1.parse","pydantic.v1.types","pydantic.v1.typing","json","functools","pathlib","typing","builtins","_frozen_importlib","abc","enum","json.decoder","os"],"hash":"e95b5a605014af8d02b8e968f378637b8d3eaf02","id":"pydantic.v1.tools","ignore_all":true,"interface_hash":"b2490f58215bc9df339ddfb1847f05be47258a8a","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/tools.py","plugin_data":null,"size":2881,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/types.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/types.data.json new file mode 100644 index 0000000000000000000000000000000000000000..66e5dff2ccc92364e3b8586690a37e508a2452bb --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/types.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic.v1.types","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Annotated":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Annotated","kind":"Gdef","module_public":false},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_public":false},"BYTE_SIZES":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.types.BYTE_SIZES","name":"BYTE_SIZES","setter_type":null,"type":{".class":"Instance","args":["builtins.str","builtins.int"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"BaseModel":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.main.BaseModel","kind":"Gdef","module_public":false},"ByteSize":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.int"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.types.ByteSize","name":"ByteSize","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.types.ByteSize","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.types","mro":["pydantic.v1.types.ByteSize","builtins.int","builtins.object"],"names":{".class":"SymbolTable","__get_validators__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.ByteSize.__get_validators__","name":"__get_validators__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ByteSize"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of ByteSize","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.ByteSize.__get_validators__","name":"__get_validators__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ByteSize"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of ByteSize","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"human_readable":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","decimal"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.types.ByteSize.human_readable","name":"human_readable","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","decimal"],"arg_types":["pydantic.v1.types.ByteSize","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"human_readable of ByteSize","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"to":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","unit"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.types.ByteSize.to","name":"to","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","unit"],"arg_types":["pydantic.v1.types.ByteSize","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"to of ByteSize","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"validate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","v"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.ByteSize.validate","name":"validate","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","v"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ByteSize"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.StrIntFloat"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate of ByteSize","ret_type":"pydantic.v1.types.ByteSize","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.ByteSize.validate","name":"validate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","v"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ByteSize"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.StrIntFloat"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate of ByteSize","ret_type":"pydantic.v1.types.ByteSize","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.ByteSize.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.types.ByteSize","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef","module_public":false},"CallableGenerator":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.CallableGenerator","kind":"Gdef","module_public":false},"ClassVar":{".class":"SymbolTableNode","cross_ref":"typing.ClassVar","kind":"Gdef","module_public":false},"ConstrainedBytes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.bytes"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.types.ConstrainedBytes","name":"ConstrainedBytes","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.types.ConstrainedBytes","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic.v1.types","mro":["pydantic.v1.types.ConstrainedBytes","builtins.bytes","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","__get_validators__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.ConstrainedBytes.__get_validators__","name":"__get_validators__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedBytes"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of ConstrainedBytes","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.ConstrainedBytes.__get_validators__","name":"__get_validators__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedBytes"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of ConstrainedBytes","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__modify_schema__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","field_schema"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.ConstrainedBytes.__modify_schema__","name":"__modify_schema__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field_schema"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedBytes"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__modify_schema__ of ConstrainedBytes","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.ConstrainedBytes.__modify_schema__","name":"__modify_schema__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field_schema"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedBytes"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__modify_schema__ of ConstrainedBytes","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"max_length":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedBytes.max_length","name":"max_length","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.OptionalInt"}}},"min_length":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedBytes.min_length","name":"min_length","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.OptionalInt"}}},"strict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedBytes.strict","name":"strict","setter_type":null,"type":"builtins.bool"}},"strip_whitespace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedBytes.strip_whitespace","name":"strip_whitespace","setter_type":null,"type":"builtins.bool"}},"to_lower":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedBytes.to_lower","name":"to_lower","setter_type":null,"type":"builtins.bool"}},"to_upper":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedBytes.to_upper","name":"to_upper","setter_type":null,"type":"builtins.bool"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.ConstrainedBytes.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.types.ConstrainedBytes","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ConstrainedDate":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["datetime.date"],"dataclass_transform_spec":null,"declared_metaclass":"pydantic.v1.types.ConstrainedNumberMeta","defn":{".class":"ClassDef","fullname":"pydantic.v1.types.ConstrainedDate","name":"ConstrainedDate","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.types.ConstrainedDate","has_param_spec_type":false,"metaclass_type":"pydantic.v1.types.ConstrainedNumberMeta","metadata":{},"module_name":"pydantic.v1.types","mro":["pydantic.v1.types.ConstrainedDate","datetime.date","builtins.object"],"names":{".class":"SymbolTable","__get_validators__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.ConstrainedDate.__get_validators__","name":"__get_validators__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedDate"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of ConstrainedDate","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.ConstrainedDate.__get_validators__","name":"__get_validators__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedDate"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of ConstrainedDate","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__modify_schema__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","field_schema"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.ConstrainedDate.__modify_schema__","name":"__modify_schema__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field_schema"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedDate"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__modify_schema__ of ConstrainedDate","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.ConstrainedDate.__modify_schema__","name":"__modify_schema__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field_schema"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedDate"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__modify_schema__ of ConstrainedDate","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"ge":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedDate.ge","name":"ge","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.OptionalDate"}}},"gt":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedDate.gt","name":"gt","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.OptionalDate"}}},"le":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedDate.le","name":"le","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.OptionalDate"}}},"lt":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedDate.lt","name":"lt","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.OptionalDate"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.ConstrainedDate.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.types.ConstrainedDate","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ConstrainedDecimal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["decimal.Decimal"],"dataclass_transform_spec":null,"declared_metaclass":"pydantic.v1.types.ConstrainedNumberMeta","defn":{".class":"ClassDef","fullname":"pydantic.v1.types.ConstrainedDecimal","name":"ConstrainedDecimal","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.types.ConstrainedDecimal","has_param_spec_type":false,"metaclass_type":"pydantic.v1.types.ConstrainedNumberMeta","metadata":{},"module_name":"pydantic.v1.types","mro":["pydantic.v1.types.ConstrainedDecimal","decimal.Decimal","builtins.object"],"names":{".class":"SymbolTable","__get_validators__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.ConstrainedDecimal.__get_validators__","name":"__get_validators__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedDecimal"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of ConstrainedDecimal","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.ConstrainedDecimal.__get_validators__","name":"__get_validators__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedDecimal"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of ConstrainedDecimal","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__modify_schema__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","field_schema"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.ConstrainedDecimal.__modify_schema__","name":"__modify_schema__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field_schema"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedDecimal"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__modify_schema__ of ConstrainedDecimal","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.ConstrainedDecimal.__modify_schema__","name":"__modify_schema__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field_schema"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedDecimal"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__modify_schema__ of ConstrainedDecimal","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"decimal_places":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedDecimal.decimal_places","name":"decimal_places","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.OptionalInt"}}},"ge":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedDecimal.ge","name":"ge","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.OptionalIntFloatDecimal"}}},"gt":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedDecimal.gt","name":"gt","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.OptionalIntFloatDecimal"}}},"le":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedDecimal.le","name":"le","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.OptionalIntFloatDecimal"}}},"lt":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedDecimal.lt","name":"lt","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.OptionalIntFloatDecimal"}}},"max_digits":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedDecimal.max_digits","name":"max_digits","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.OptionalInt"}}},"multiple_of":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedDecimal.multiple_of","name":"multiple_of","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.OptionalIntFloatDecimal"}}},"validate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.ConstrainedDecimal.validate","name":"validate","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","value"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedDecimal"},"decimal.Decimal"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate of ConstrainedDecimal","ret_type":"decimal.Decimal","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.ConstrainedDecimal.validate","name":"validate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","value"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedDecimal"},"decimal.Decimal"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate of ConstrainedDecimal","ret_type":"decimal.Decimal","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.ConstrainedDecimal.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.types.ConstrainedDecimal","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ConstrainedFloat":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.float"],"dataclass_transform_spec":null,"declared_metaclass":"pydantic.v1.types.ConstrainedNumberMeta","defn":{".class":"ClassDef","fullname":"pydantic.v1.types.ConstrainedFloat","name":"ConstrainedFloat","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.types.ConstrainedFloat","has_param_spec_type":false,"metaclass_type":"pydantic.v1.types.ConstrainedNumberMeta","metadata":{},"module_name":"pydantic.v1.types","mro":["pydantic.v1.types.ConstrainedFloat","builtins.float","builtins.object"],"names":{".class":"SymbolTable","__get_validators__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.ConstrainedFloat.__get_validators__","name":"__get_validators__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedFloat"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of ConstrainedFloat","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.ConstrainedFloat.__get_validators__","name":"__get_validators__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedFloat"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of ConstrainedFloat","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__modify_schema__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","field_schema"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.ConstrainedFloat.__modify_schema__","name":"__modify_schema__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field_schema"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedFloat"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__modify_schema__ of ConstrainedFloat","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.ConstrainedFloat.__modify_schema__","name":"__modify_schema__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field_schema"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedFloat"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__modify_schema__ of ConstrainedFloat","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"allow_inf_nan":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedFloat.allow_inf_nan","name":"allow_inf_nan","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"ge":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedFloat.ge","name":"ge","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.OptionalIntFloat"}}},"gt":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedFloat.gt","name":"gt","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.OptionalIntFloat"}}},"le":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedFloat.le","name":"le","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.OptionalIntFloat"}}},"lt":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedFloat.lt","name":"lt","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.OptionalIntFloat"}}},"multiple_of":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedFloat.multiple_of","name":"multiple_of","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.OptionalIntFloat"}}},"strict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedFloat.strict","name":"strict","setter_type":null,"type":"builtins.bool"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.ConstrainedFloat.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.types.ConstrainedFloat","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ConstrainedFrozenSet":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.frozenset"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.types.ConstrainedFrozenSet","name":"ConstrainedFrozenSet","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.types.ConstrainedFrozenSet","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic.v1.types","mro":["pydantic.v1.types.ConstrainedFrozenSet","builtins.frozenset","typing.AbstractSet","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","__args__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic.v1.types.ConstrainedFrozenSet.__args__","name":"__args__","setter_type":null,"type":{".class":"Instance","args":[{".class":"TypeType","item":{".class":"UnboundType","args":[],"expr":null,"expr_fallback":null,"name":"T"}}],"extra_attrs":null,"type_ref":"builtins.frozenset"}}},"__get_validators__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.ConstrainedFrozenSet.__get_validators__","name":"__get_validators__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedFrozenSet"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of ConstrainedFrozenSet","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.ConstrainedFrozenSet.__get_validators__","name":"__get_validators__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedFrozenSet"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of ConstrainedFrozenSet","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__modify_schema__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","field_schema"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.ConstrainedFrozenSet.__modify_schema__","name":"__modify_schema__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field_schema"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedFrozenSet"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__modify_schema__ of ConstrainedFrozenSet","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.ConstrainedFrozenSet.__modify_schema__","name":"__modify_schema__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field_schema"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedFrozenSet"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__modify_schema__ of ConstrainedFrozenSet","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__origin__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_staticmethod","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedFrozenSet.__origin__","name":"__origin__","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"abc.ABCMeta","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"builtins._T_co","id":1,"name":"_T_co","namespace":"builtins.frozenset","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"builtins.frozenset"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"builtins._T_co","id":1,"name":"_T_co","namespace":"builtins.frozenset","upper_bound":"builtins.object","values":[],"variance":1}]},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"builtins._T_co","id":1,"name":"_T_co","namespace":"builtins.frozenset","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"abc.ABCMeta","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"builtins._T_co","id":1,"name":"_T_co","namespace":"builtins.frozenset","upper_bound":"builtins.object","values":[],"variance":1}],"extra_attrs":null,"type_ref":"builtins.frozenset"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"builtins._T_co","id":1,"name":"_T_co","namespace":"builtins.frozenset","upper_bound":"builtins.object","values":[],"variance":1}]}]}}},"frozenset_length_validator":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","v"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.ConstrainedFrozenSet.frozenset_length_validator","name":"frozenset_length_validator","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","v"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedFrozenSet"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types.ConstrainedFrozenSet.frozenset_length_validator","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.frozenset"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frozenset_length_validator of ConstrainedFrozenSet","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types.ConstrainedFrozenSet.frozenset_length_validator","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.frozenset"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types.ConstrainedFrozenSet.frozenset_length_validator","upper_bound":"builtins.object","values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.ConstrainedFrozenSet.frozenset_length_validator","name":"frozenset_length_validator","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","v"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedFrozenSet"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types.ConstrainedFrozenSet.frozenset_length_validator","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.frozenset"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frozenset_length_validator of ConstrainedFrozenSet","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types.ConstrainedFrozenSet.frozenset_length_validator","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.frozenset"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types.ConstrainedFrozenSet.frozenset_length_validator","upper_bound":"builtins.object","values":[],"variance":0}]}}}},"item_type":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic.v1.types.ConstrainedFrozenSet.item_type","name":"item_type","setter_type":null,"type":{".class":"TypeType","item":{".class":"UnboundType","args":[],"expr":null,"expr_fallback":null,"name":"T"}}}},"max_items":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedFrozenSet.max_items","name":"max_items","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"min_items":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedFrozenSet.min_items","name":"min_items","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.ConstrainedFrozenSet.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.types.ConstrainedFrozenSet","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ConstrainedInt":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.int"],"dataclass_transform_spec":null,"declared_metaclass":"pydantic.v1.types.ConstrainedNumberMeta","defn":{".class":"ClassDef","fullname":"pydantic.v1.types.ConstrainedInt","name":"ConstrainedInt","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.types.ConstrainedInt","has_param_spec_type":false,"metaclass_type":"pydantic.v1.types.ConstrainedNumberMeta","metadata":{},"module_name":"pydantic.v1.types","mro":["pydantic.v1.types.ConstrainedInt","builtins.int","builtins.object"],"names":{".class":"SymbolTable","__get_validators__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.ConstrainedInt.__get_validators__","name":"__get_validators__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedInt"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of ConstrainedInt","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.ConstrainedInt.__get_validators__","name":"__get_validators__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedInt"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of ConstrainedInt","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__modify_schema__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","field_schema"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.ConstrainedInt.__modify_schema__","name":"__modify_schema__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field_schema"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedInt"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__modify_schema__ of ConstrainedInt","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.ConstrainedInt.__modify_schema__","name":"__modify_schema__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field_schema"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedInt"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__modify_schema__ of ConstrainedInt","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"ge":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedInt.ge","name":"ge","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.OptionalInt"}}},"gt":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedInt.gt","name":"gt","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.OptionalInt"}}},"le":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedInt.le","name":"le","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.OptionalInt"}}},"lt":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedInt.lt","name":"lt","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.OptionalInt"}}},"multiple_of":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedInt.multiple_of","name":"multiple_of","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.OptionalInt"}}},"strict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedInt.strict","name":"strict","setter_type":null,"type":"builtins.bool"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.ConstrainedInt.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.types.ConstrainedInt","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ConstrainedList":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.list"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.types.ConstrainedList","name":"ConstrainedList","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.types.ConstrainedList","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic.v1.types","mro":["pydantic.v1.types.ConstrainedList","builtins.list","typing.MutableSequence","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","__args__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic.v1.types.ConstrainedList.__args__","name":"__args__","setter_type":null,"type":{".class":"Instance","args":[{".class":"TypeType","item":{".class":"UnboundType","args":[],"expr":null,"expr_fallback":null,"name":"T"}}],"extra_attrs":null,"type_ref":"builtins.tuple"}}},"__get_validators__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.ConstrainedList.__get_validators__","name":"__get_validators__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedList"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of ConstrainedList","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.ConstrainedList.__get_validators__","name":"__get_validators__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedList"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of ConstrainedList","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__modify_schema__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","field_schema"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.ConstrainedList.__modify_schema__","name":"__modify_schema__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field_schema"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedList"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__modify_schema__ of ConstrainedList","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.ConstrainedList.__modify_schema__","name":"__modify_schema__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field_schema"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedList"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__modify_schema__ of ConstrainedList","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__origin__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedList.__origin__","name":"__origin__","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"abc.ABCMeta","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"builtins._T","id":1,"name":"_T","namespace":"builtins.list","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"builtins._T","id":1,"name":"_T","namespace":"builtins.list","upper_bound":"builtins.object","values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"builtins._T","id":1,"name":"_T","namespace":"builtins.list","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"abc.ABCMeta","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"builtins._T","id":1,"name":"_T","namespace":"builtins.list","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"builtins._T","id":1,"name":"_T","namespace":"builtins.list","upper_bound":"builtins.object","values":[],"variance":0}]}]}}},"item_type":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic.v1.types.ConstrainedList.item_type","name":"item_type","setter_type":null,"type":{".class":"TypeType","item":{".class":"UnboundType","args":[],"expr":null,"expr_fallback":null,"name":"T"}}}},"list_length_validator":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","v"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.ConstrainedList.list_length_validator","name":"list_length_validator","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","v"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedList"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types.ConstrainedList.list_length_validator","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"list_length_validator of ConstrainedList","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types.ConstrainedList.list_length_validator","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types.ConstrainedList.list_length_validator","upper_bound":"builtins.object","values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.ConstrainedList.list_length_validator","name":"list_length_validator","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","v"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedList"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types.ConstrainedList.list_length_validator","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"list_length_validator of ConstrainedList","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types.ConstrainedList.list_length_validator","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types.ConstrainedList.list_length_validator","upper_bound":"builtins.object","values":[],"variance":0}]}}}},"max_items":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedList.max_items","name":"max_items","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"min_items":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedList.min_items","name":"min_items","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"unique_items":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedList.unique_items","name":"unique_items","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"unique_items_validator":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","v"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.ConstrainedList.unique_items_validator","name":"unique_items_validator","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","v"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedList"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types.ConstrainedList.unique_items_validator","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique_items_validator of ConstrainedList","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types.ConstrainedList.unique_items_validator","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types.ConstrainedList.unique_items_validator","upper_bound":"builtins.object","values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.ConstrainedList.unique_items_validator","name":"unique_items_validator","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","v"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedList"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types.ConstrainedList.unique_items_validator","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique_items_validator of ConstrainedList","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types.ConstrainedList.unique_items_validator","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types.ConstrainedList.unique_items_validator","upper_bound":"builtins.object","values":[],"variance":0}]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.ConstrainedList.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.types.ConstrainedList","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ConstrainedNumberMeta":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.type"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.types.ConstrainedNumberMeta","name":"ConstrainedNumberMeta","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.types.ConstrainedNumberMeta","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.types","mro":["pydantic.v1.types.ConstrainedNumberMeta","builtins.type","builtins.object"],"names":{".class":"SymbolTable","__new__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["cls","name","bases","dct"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_trivial_self"],"fullname":"pydantic.v1.types.ConstrainedNumberMeta.__new__","name":"__new__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["cls","name","bases","dct"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedNumberMeta"},"builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of ConstrainedNumberMeta","ret_type":"pydantic.v1.types.ConstrainedInt","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.ConstrainedNumberMeta.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.types.ConstrainedNumberMeta","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ConstrainedSet":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.set"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.types.ConstrainedSet","name":"ConstrainedSet","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.types.ConstrainedSet","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic.v1.types","mro":["pydantic.v1.types.ConstrainedSet","builtins.set","typing.MutableSet","typing.AbstractSet","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","__args__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic.v1.types.ConstrainedSet.__args__","name":"__args__","setter_type":null,"type":{".class":"Instance","args":[{".class":"TypeType","item":{".class":"UnboundType","args":[],"expr":null,"expr_fallback":null,"name":"T"}}],"extra_attrs":null,"type_ref":"builtins.set"}}},"__get_validators__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.ConstrainedSet.__get_validators__","name":"__get_validators__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedSet"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of ConstrainedSet","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.ConstrainedSet.__get_validators__","name":"__get_validators__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedSet"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of ConstrainedSet","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__modify_schema__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","field_schema"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.ConstrainedSet.__modify_schema__","name":"__modify_schema__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field_schema"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedSet"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__modify_schema__ of ConstrainedSet","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.ConstrainedSet.__modify_schema__","name":"__modify_schema__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field_schema"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedSet"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__modify_schema__ of ConstrainedSet","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__origin__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedSet.__origin__","name":"__origin__","setter_type":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"abc.ABCMeta","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"builtins._T","id":1,"name":"_T","namespace":"builtins.set","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.set"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"builtins._T","id":1,"name":"_T","namespace":"builtins.set","upper_bound":"builtins.object","values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"builtins._T","id":1,"name":"_T","namespace":"builtins.set","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"abc.ABCMeta","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"builtins._T","id":1,"name":"_T","namespace":"builtins.set","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.set"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"builtins._T","id":1,"name":"_T","namespace":"builtins.set","upper_bound":"builtins.object","values":[],"variance":0}]}]}}},"item_type":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic.v1.types.ConstrainedSet.item_type","name":"item_type","setter_type":null,"type":{".class":"TypeType","item":{".class":"UnboundType","args":[],"expr":null,"expr_fallback":null,"name":"T"}}}},"max_items":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedSet.max_items","name":"max_items","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"min_items":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedSet.min_items","name":"min_items","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"set_length_validator":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","v"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.ConstrainedSet.set_length_validator","name":"set_length_validator","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","v"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedSet"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types.ConstrainedSet.set_length_validator","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"set_length_validator of ConstrainedSet","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types.ConstrainedSet.set_length_validator","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types.ConstrainedSet.set_length_validator","upper_bound":"builtins.object","values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.ConstrainedSet.set_length_validator","name":"set_length_validator","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","v"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedSet"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types.ConstrainedSet.set_length_validator","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"set_length_validator of ConstrainedSet","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types.ConstrainedSet.set_length_validator","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.set"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types.ConstrainedSet.set_length_validator","upper_bound":"builtins.object","values":[],"variance":0}]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.ConstrainedSet.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.types.ConstrainedSet","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ConstrainedStr":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.str"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.types.ConstrainedStr","name":"ConstrainedStr","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.types.ConstrainedStr","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic.v1.types","mro":["pydantic.v1.types.ConstrainedStr","builtins.str","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","__get_validators__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.ConstrainedStr.__get_validators__","name":"__get_validators__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedStr"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of ConstrainedStr","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.ConstrainedStr.__get_validators__","name":"__get_validators__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedStr"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of ConstrainedStr","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__modify_schema__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","field_schema"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.ConstrainedStr.__modify_schema__","name":"__modify_schema__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field_schema"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedStr"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__modify_schema__ of ConstrainedStr","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.ConstrainedStr.__modify_schema__","name":"__modify_schema__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field_schema"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedStr"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__modify_schema__ of ConstrainedStr","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"_get_pattern":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["regex"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"pydantic.v1.types.ConstrainedStr._get_pattern","name":"_get_pattern","original_first_arg":"regex","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["regex"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_pattern of ConstrainedStr","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_staticmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.ConstrainedStr._get_pattern","name":"_get_pattern","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["regex"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_pattern of ConstrainedStr","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"curtail_length":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedStr.curtail_length","name":"curtail_length","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.OptionalInt"}}},"max_length":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedStr.max_length","name":"max_length","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.OptionalInt"}}},"min_length":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedStr.min_length","name":"min_length","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.OptionalInt"}}},"regex":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedStr.regex","name":"regex","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"strict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedStr.strict","name":"strict","setter_type":null,"type":"builtins.bool"}},"strip_whitespace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedStr.strip_whitespace","name":"strip_whitespace","setter_type":null,"type":"builtins.bool"}},"to_lower":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedStr.to_lower","name":"to_lower","setter_type":null,"type":"builtins.bool"}},"to_upper":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.types.ConstrainedStr.to_upper","name":"to_upper","setter_type":null,"type":"builtins.bool"}},"validate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.ConstrainedStr.validate","name":"validate","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","value"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedStr"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate of ConstrainedStr","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.ConstrainedStr.validate","name":"validate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","value"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.ConstrainedStr"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate of ConstrainedStr","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.ConstrainedStr.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.types.ConstrainedStr","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Dataclass":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.dataclasses.Dataclass","kind":"Gdef","module_public":false},"Decimal":{".class":"SymbolTableNode","cross_ref":"decimal.Decimal","kind":"Gdef","module_public":false},"Dict":{".class":"SymbolTableNode","cross_ref":"typing.Dict","kind":"Gdef","module_public":false},"DirectoryPath":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.types.DirectoryPath","line":782,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":"pathlib.Path"}},"Enum":{".class":"SymbolTableNode","cross_ref":"enum.Enum","kind":"Gdef","module_public":false},"FilePath":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.types.FilePath","line":781,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":"pathlib.Path"}},"FiniteFloat":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.types.FiniteFloat","line":327,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":"builtins.float"}},"FrozenSet":{".class":"SymbolTableNode","cross_ref":"typing.FrozenSet","kind":"Gdef","module_public":false},"FutureDate":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.types.FutureDate","line":1150,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":"datetime.date"}},"InvalidOperation":{".class":"SymbolTableNode","cross_ref":"decimal.InvalidOperation","kind":"Gdef","module_public":false},"Json":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":1,"name":"T","namespace":"pydantic.v1.types.Json","upper_bound":"builtins.object","values":[],"variance":0}],"column":4,"fullname":"pydantic.v1.types.Json","line":837,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":1,"name":"T","namespace":"pydantic.v1.types.Json","upper_bound":"builtins.object","values":[],"variance":0}}},"JsonMeta":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.type"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.types.JsonMeta","name":"JsonMeta","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.types.JsonMeta","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.types","mro":["pydantic.v1.types.JsonMeta","builtins.type","builtins.object"],"names":{".class":"SymbolTable","__getitem__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.types.JsonMeta.__getitem__","name":"__getitem__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["pydantic.v1.types.JsonMeta",{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of JsonMeta","ret_type":{".class":"TypeType","item":"pydantic.v1.types.JsonWrapper"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.JsonMeta.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.types.JsonMeta","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"JsonWrapper":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.types.JsonWrapper","name":"JsonWrapper","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.types.JsonWrapper","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.types","mro":["pydantic.v1.types.JsonWrapper","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.JsonWrapper.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.types.JsonWrapper","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"List":{".class":"SymbolTableNode","cross_ref":"typing.List","kind":"Gdef","module_public":false},"ModelOrDc":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.types.ModelOrDc","line":130,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"TypeType","item":"pydantic.v1.main.BaseModel"},{".class":"TypeType","item":"pydantic.v1.dataclasses.Dataclass"}],"uses_pep604_syntax":false}}},"NegativeFloat":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.types.NegativeFloat","line":323,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":"builtins.float"}},"NegativeInt":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.types.NegativeInt","line":244,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":"builtins.int"}},"NonNegativeFloat":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.types.NonNegativeFloat","line":325,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":"builtins.float"}},"NonNegativeInt":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.types.NonNegativeInt","line":246,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":"builtins.int"}},"NonPositiveFloat":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.types.NonPositiveFloat","line":324,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":"builtins.float"}},"NonPositiveInt":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.types.NonPositiveInt","line":245,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":"builtins.int"}},"NoneBytes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic.v1.types.NoneBytes","line":114,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["builtins.bytes",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"NoneStr":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic.v1.types.NoneStr","line":113,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"NoneStrBytes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic.v1.types.NoneStrBytes","line":116,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.StrBytes"},{".class":"NoneType"}],"uses_pep604_syntax":false}}},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef","module_public":false},"OptionalDate":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic.v1.types.OptionalDate","line":120,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["datetime.date",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"OptionalInt":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic.v1.types.OptionalInt","line":117,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"OptionalIntFloat":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic.v1.types.OptionalIntFloat","line":118,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.OptionalInt"},"builtins.float"],"uses_pep604_syntax":false}}},"OptionalIntFloatDecimal":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic.v1.types.OptionalIntFloatDecimal","line":119,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.OptionalIntFloat"},"decimal.Decimal"],"uses_pep604_syntax":false}}},"PastDate":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.types.PastDate","line":1149,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":"datetime.date"}},"Path":{".class":"SymbolTableNode","cross_ref":"pathlib.Path","kind":"Gdef","module_public":false},"Pattern":{".class":"SymbolTableNode","cross_ref":"re.Pattern","kind":"Gdef","module_public":false},"PaymentCardBrand":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.str","enum.Enum"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.types.PaymentCardBrand","name":"PaymentCardBrand","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_enum"],"fullname":"pydantic.v1.types.PaymentCardBrand","has_param_spec_type":false,"metaclass_type":"enum.EnumMeta","metadata":{},"module_name":"pydantic.v1.types","mro":["pydantic.v1.types.PaymentCardBrand","builtins.str","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","enum.Enum","builtins.object"],"names":{".class":"SymbolTable","__str__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.types.PaymentCardBrand.__str__","name":"__str__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["pydantic.v1.types.PaymentCardBrand"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__str__ of PaymentCardBrand","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"amex":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.types.PaymentCardBrand.amex","name":"amex","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.str","value":"American Express"},"type_ref":"builtins.str"}}},"mastercard":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.types.PaymentCardBrand.mastercard","name":"mastercard","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.str","value":"Mastercard"},"type_ref":"builtins.str"}}},"other":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.types.PaymentCardBrand.other","name":"other","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.str","value":"other"},"type_ref":"builtins.str"}}},"visa":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.types.PaymentCardBrand.visa","name":"visa","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.str","value":"Visa"},"type_ref":"builtins.str"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.PaymentCardBrand.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.types.PaymentCardBrand","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"PaymentCardNumber":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.str"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.types.PaymentCardNumber","name":"PaymentCardNumber","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.types.PaymentCardNumber","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic.v1.types","mro":["pydantic.v1.types.PaymentCardNumber","builtins.str","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","__get_validators__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.PaymentCardNumber.__get_validators__","name":"__get_validators__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.PaymentCardNumber"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of PaymentCardNumber","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.PaymentCardNumber.__get_validators__","name":"__get_validators__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.PaymentCardNumber"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of PaymentCardNumber","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","card_number"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.types.PaymentCardNumber.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","card_number"],"arg_types":["pydantic.v1.types.PaymentCardNumber","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of PaymentCardNumber","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_get_brand":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["card_number"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"pydantic.v1.types.PaymentCardNumber._get_brand","name":"_get_brand","original_first_arg":"card_number","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["card_number"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_brand of PaymentCardNumber","ret_type":"pydantic.v1.types.PaymentCardBrand","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_staticmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.PaymentCardNumber._get_brand","name":"_get_brand","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["card_number"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_brand of PaymentCardNumber","ret_type":"pydantic.v1.types.PaymentCardBrand","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"bin":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic.v1.types.PaymentCardNumber.bin","name":"bin","setter_type":null,"type":"builtins.str"}},"brand":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic.v1.types.PaymentCardNumber.brand","name":"brand","setter_type":null,"type":"pydantic.v1.types.PaymentCardBrand"}},"last4":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"pydantic.v1.types.PaymentCardNumber.last4","name":"last4","setter_type":null,"type":"builtins.str"}},"masked":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.PaymentCardNumber.masked","name":"masked","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.types.PaymentCardNumber"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"masked of PaymentCardNumber","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"pydantic.v1.types.PaymentCardNumber.masked","name":"masked","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.types.PaymentCardNumber"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"masked of PaymentCardNumber","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"max_length":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.PaymentCardNumber.max_length","name":"max_length","setter_type":null,"type":"builtins.int"}},"min_length":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.PaymentCardNumber.min_length","name":"min_length","setter_type":null,"type":"builtins.int"}},"strip_whitespace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.PaymentCardNumber.strip_whitespace","name":"strip_whitespace","setter_type":null,"type":"builtins.bool"}},"validate_digits":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","card_number"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.PaymentCardNumber.validate_digits","name":"validate_digits","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","card_number"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.PaymentCardNumber"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate_digits of PaymentCardNumber","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.PaymentCardNumber.validate_digits","name":"validate_digits","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","card_number"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.PaymentCardNumber"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate_digits of PaymentCardNumber","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"validate_length_for_brand":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","card_number"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.PaymentCardNumber.validate_length_for_brand","name":"validate_length_for_brand","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","card_number"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.PaymentCardNumber"},"pydantic.v1.types.PaymentCardNumber"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate_length_for_brand of PaymentCardNumber","ret_type":"pydantic.v1.types.PaymentCardNumber","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.PaymentCardNumber.validate_length_for_brand","name":"validate_length_for_brand","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","card_number"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.PaymentCardNumber"},"pydantic.v1.types.PaymentCardNumber"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate_length_for_brand of PaymentCardNumber","ret_type":"pydantic.v1.types.PaymentCardNumber","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"validate_luhn_check_digit":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","card_number"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.PaymentCardNumber.validate_luhn_check_digit","name":"validate_luhn_check_digit","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","card_number"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.PaymentCardNumber"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate_luhn_check_digit of PaymentCardNumber","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.PaymentCardNumber.validate_luhn_check_digit","name":"validate_luhn_check_digit","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","card_number"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.PaymentCardNumber"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate_luhn_check_digit of PaymentCardNumber","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.PaymentCardNumber.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.types.PaymentCardNumber","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"PositiveFloat":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.types.PositiveFloat","line":322,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":"builtins.float"}},"PositiveInt":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.types.PositiveInt","line":243,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":"builtins.int"}},"PyObject":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.types.PyObject","line":638,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"SecretBytes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.types.SecretField"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.types.SecretBytes","name":"SecretBytes","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.types.SecretBytes","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic.v1.types","mro":["pydantic.v1.types.SecretBytes","pydantic.v1.types.SecretField","abc.ABC","builtins.object"],"names":{".class":"SymbolTable","__get_validators__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.SecretBytes.__get_validators__","name":"__get_validators__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.SecretBytes"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of SecretBytes","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.SecretBytes.__get_validators__","name":"__get_validators__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.SecretBytes"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of SecretBytes","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.types.SecretBytes.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","value"],"arg_types":["pydantic.v1.types.SecretBytes","builtins.bytes"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of SecretBytes","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__len__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.types.SecretBytes.__len__","name":"__len__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["pydantic.v1.types.SecretBytes"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__len__ of SecretBytes","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__modify_schema__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","field_schema"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.SecretBytes.__modify_schema__","name":"__modify_schema__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field_schema"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.SecretBytes"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__modify_schema__ of SecretBytes","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.SecretBytes.__modify_schema__","name":"__modify_schema__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field_schema"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.SecretBytes"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__modify_schema__ of SecretBytes","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.types.SecretBytes.__repr__","name":"__repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["pydantic.v1.types.SecretBytes"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr__ of SecretBytes","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_secret_value":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.types.SecretBytes._secret_value","name":"_secret_value","setter_type":null,"type":"builtins.bytes"}},"display":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.types.SecretBytes.display","name":"display","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.types.SecretBytes"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"display of SecretBytes","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_secret_value":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.types.SecretBytes.get_secret_value","name":"get_secret_value","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.types.SecretBytes"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_secret_value of SecretBytes","ret_type":"builtins.bytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"max_length":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.SecretBytes.max_length","name":"max_length","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.OptionalInt"}}},"min_length":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.SecretBytes.min_length","name":"min_length","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.OptionalInt"}}},"validate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.SecretBytes.validate","name":"validate","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","value"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.SecretBytes"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate of SecretBytes","ret_type":"pydantic.v1.types.SecretBytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.SecretBytes.validate","name":"validate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","value"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.SecretBytes"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate of SecretBytes","ret_type":"pydantic.v1.types.SecretBytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.SecretBytes.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.types.SecretBytes","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"SecretField":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[["get_secret_value",1]],"alt_promote":null,"bases":["abc.ABC"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.types.SecretField","name":"SecretField","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_abstract"],"fullname":"pydantic.v1.types.SecretField","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic.v1.types","mro":["pydantic.v1.types.SecretField","abc.ABC","builtins.object"],"names":{".class":"SymbolTable","__eq__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.types.SecretField.__eq__","name":"__eq__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["pydantic.v1.types.SecretField",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__eq__ of SecretField","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__hash__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.types.SecretField.__hash__","name":"__hash__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.types.SecretField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__hash__ of SecretField","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__str__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.types.SecretField.__str__","name":"__str__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["pydantic.v1.types.SecretField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__str__ of SecretField","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_secret_value":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":1,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated","is_trivial_body","is_trivial_self"],"fullname":"pydantic.v1.types.SecretField.get_secret_value","name":"get_secret_value","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.types.SecretField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_secret_value of SecretField","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred"],"fullname":"pydantic.v1.types.SecretField.get_secret_value","name":"get_secret_value","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.types.SecretField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_secret_value of SecretField","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.SecretField.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.types.SecretField","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"SecretStr":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.types.SecretField"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.types.SecretStr","name":"SecretStr","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.types.SecretStr","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic.v1.types","mro":["pydantic.v1.types.SecretStr","pydantic.v1.types.SecretField","abc.ABC","builtins.object"],"names":{".class":"SymbolTable","__get_validators__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["cls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.SecretStr.__get_validators__","name":"__get_validators__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.SecretStr"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of SecretStr","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.SecretStr.__get_validators__","name":"__get_validators__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["cls"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.SecretStr"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get_validators__ of SecretStr","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.CallableGenerator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.types.SecretStr.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","value"],"arg_types":["pydantic.v1.types.SecretStr","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of SecretStr","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__len__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.types.SecretStr.__len__","name":"__len__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["pydantic.v1.types.SecretStr"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__len__ of SecretStr","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__modify_schema__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","field_schema"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.SecretStr.__modify_schema__","name":"__modify_schema__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field_schema"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.SecretStr"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__modify_schema__ of SecretStr","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.SecretStr.__modify_schema__","name":"__modify_schema__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","field_schema"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.SecretStr"},{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__modify_schema__ of SecretStr","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.types.SecretStr.__repr__","name":"__repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["pydantic.v1.types.SecretStr"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr__ of SecretStr","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_secret_value":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.types.SecretStr._secret_value","name":"_secret_value","setter_type":null,"type":"builtins.str"}},"display":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.types.SecretStr.display","name":"display","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.types.SecretStr"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"display of SecretStr","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_secret_value":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.types.SecretStr.get_secret_value","name":"get_secret_value","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.types.SecretStr"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_secret_value of SecretStr","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"max_length":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.SecretStr.max_length","name":"max_length","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.OptionalInt"}}},"min_length":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"pydantic.v1.types.SecretStr.min_length","name":"min_length","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.types.OptionalInt"}}},"validate":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.types.SecretStr.validate","name":"validate","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","value"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.SecretStr"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate of SecretStr","ret_type":"pydantic.v1.types.SecretStr","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.types.SecretStr.validate","name":"validate","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","value"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.types.SecretStr"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate of SecretStr","ret_type":"pydantic.v1.types.SecretStr","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.SecretStr.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.types.SecretStr","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Set":{".class":"SymbolTableNode","cross_ref":"typing.Set","kind":"Gdef","module_public":false},"StrBytes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic.v1.types.StrBytes","line":115,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["builtins.str","builtins.bytes"],"uses_pep604_syntax":false}}},"StrIntFloat":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic.v1.types.StrIntFloat","line":121,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["builtins.str","builtins.int","builtins.float"],"uses_pep604_syntax":false}}},"StrictBool":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.types.StrictBool","line":172,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":"builtins.bool"}},"StrictBytes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.types.StrictBytes","line":395,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":"builtins.bytes"}},"StrictFloat":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.types.StrictFloat","line":326,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":"builtins.float"}},"StrictInt":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.types.StrictInt","line":247,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":"builtins.int"}},"StrictStr":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.types.StrictStr","line":475,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":"builtins.str"}},"T":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","name":"T","upper_bound":"builtins.object","values":[],"variance":0}},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef","module_public":false},"Tuple":{".class":"SymbolTableNode","cross_ref":"typing.Tuple","kind":"Gdef","module_public":false},"Type":{".class":"SymbolTableNode","cross_ref":"typing.Type","kind":"Gdef","module_public":false},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_public":false},"UUID":{".class":"SymbolTableNode","cross_ref":"uuid.UUID","kind":"Gdef","module_public":false},"UUID1":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.types.UUID1","line":755,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":"uuid.UUID"}},"UUID3":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.types.UUID3","line":756,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":"uuid.UUID"}},"UUID4":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.types.UUID4","line":757,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":"uuid.UUID"}},"UUID5":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.types.UUID5","line":758,"no_args":true,"normalized":false,"python_3_12_type_alias":false,"target":"uuid.UUID"}},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef","module_public":false},"WeakSet":{".class":"SymbolTableNode","cross_ref":"_weakrefset.WeakSet","kind":"Gdef","module_public":false},"_DEFINED_TYPES":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic.v1.types._DEFINED_TYPES","name":"_DEFINED_TYPES","setter_type":null,"type":{".class":"Instance","args":["builtins.type"],"extra_attrs":null,"type_ref":"_weakrefset.WeakSet"}}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.types.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.types.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.types.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.types.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.types.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.types.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.types.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_registered":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"pydantic.v1.types._registered","impl":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["typ"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload"],"fullname":"pydantic.v1.types._registered","name":"_registered","original_first_arg":"typ","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["typ"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types._registered","upper_bound":"builtins.object","values":[],"variance":0}},"pydantic.v1.types.ConstrainedNumberMeta"],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_registered","ret_type":{".class":"UnionType","items":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types._registered","upper_bound":"builtins.object","values":[],"variance":0}},"pydantic.v1.types.ConstrainedNumberMeta"],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types._registered","upper_bound":"builtins.object","values":[],"variance":0}]}},"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["typ"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"pydantic.v1.types._registered","name":"_registered","original_first_arg":"typ","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["typ"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types._registered#0","upper_bound":"builtins.object","values":[],"variance":0}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_registered","ret_type":{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types._registered#0","upper_bound":"builtins.object","values":[],"variance":0}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types._registered#0","upper_bound":"builtins.object","values":[],"variance":0}]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.types._registered","name":"_registered","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["typ"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types._registered#0","upper_bound":"builtins.object","values":[],"variance":0}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_registered","ret_type":{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types._registered#0","upper_bound":"builtins.object","values":[],"variance":0}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types._registered#0","upper_bound":"builtins.object","values":[],"variance":0}]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["typ"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"pydantic.v1.types._registered","name":"_registered","original_first_arg":"typ","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["typ"],"arg_types":["pydantic.v1.types.ConstrainedNumberMeta"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_registered","ret_type":"pydantic.v1.types.ConstrainedNumberMeta","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.types._registered","name":"_registered","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["typ"],"arg_types":["pydantic.v1.types.ConstrainedNumberMeta"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_registered","ret_type":"pydantic.v1.types.ConstrainedNumberMeta","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["typ"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types._registered#0","upper_bound":"builtins.object","values":[],"variance":0}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_registered","ret_type":{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types._registered#0","upper_bound":"builtins.object","values":[],"variance":0}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types._registered#0","upper_bound":"builtins.object","values":[],"variance":0}]},{".class":"CallableType","arg_kinds":[0],"arg_names":["typ"],"arg_types":["pydantic.v1.types.ConstrainedNumberMeta"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_registered","ret_type":"pydantic.v1.types.ConstrainedNumberMeta","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"abc":{".class":"SymbolTableNode","cross_ref":"abc","kind":"Gdef","module_public":false},"byte_string_re":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.types.byte_string_re","name":"byte_string_re","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"bytes_validator":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.validators.bytes_validator","kind":"Gdef","module_public":false},"cast":{".class":"SymbolTableNode","cross_ref":"typing.cast","kind":"Gdef","module_public":false},"conbytes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5],"arg_names":["strip_whitespace","to_upper","to_lower","min_length","max_length","strict"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.types.conbytes","name":"conbytes","original_first_arg":"strip_whitespace","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5],"arg_names":["strip_whitespace","to_upper","to_lower","min_length","max_length","strict"],"arg_types":["builtins.bool","builtins.bool","builtins.bool",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"conbytes","ret_type":{".class":"TypeType","item":"builtins.bytes"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"condate":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5],"arg_names":["gt","ge","lt","le"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.types.condate","name":"condate","original_first_arg":"gt","type":{".class":"CallableType","arg_kinds":[5,5,5,5],"arg_names":["gt","ge","lt","le"],"arg_types":[{".class":"UnionType","items":["datetime.date",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["datetime.date",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["datetime.date",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["datetime.date",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"condate","ret_type":{".class":"TypeType","item":"datetime.date"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"condecimal":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5,5],"arg_names":["gt","ge","lt","le","max_digits","decimal_places","multiple_of"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.types.condecimal","name":"condecimal","original_first_arg":"gt","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5],"arg_names":["gt","ge","lt","le","max_digits","decimal_places","multiple_of"],"arg_types":[{".class":"UnionType","items":["decimal.Decimal",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["decimal.Decimal",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["decimal.Decimal",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["decimal.Decimal",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["decimal.Decimal",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"condecimal","ret_type":{".class":"TypeType","item":"decimal.Decimal"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"confloat":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5,5],"arg_names":["strict","gt","ge","lt","le","multiple_of","allow_inf_nan"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.types.confloat","name":"confloat","original_first_arg":"strict","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5],"arg_names":["strict","gt","ge","lt","le","multiple_of","allow_inf_nan"],"arg_types":["builtins.bool",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"confloat","ret_type":{".class":"TypeType","item":"builtins.float"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"confrozenset":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5],"arg_names":["item_type","min_items","max_items"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.types.confrozenset","name":"confrozenset","original_first_arg":"item_type","type":{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":["item_type","min_items","max_items"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types.confrozenset","upper_bound":"builtins.object","values":[],"variance":0}},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"confrozenset","ret_type":{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types.confrozenset","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.frozenset"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types.confrozenset","upper_bound":"builtins.object","values":[],"variance":0}]}}},"conint":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5],"arg_names":["strict","gt","ge","lt","le","multiple_of"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.types.conint","name":"conint","original_first_arg":"strict","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5],"arg_names":["strict","gt","ge","lt","le","multiple_of"],"arg_types":["builtins.bool",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"conint","ret_type":{".class":"TypeType","item":"builtins.int"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"conlist":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5],"arg_names":["item_type","min_items","max_items","unique_items"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.types.conlist","name":"conlist","original_first_arg":"item_type","type":{".class":"CallableType","arg_kinds":[0,5,5,5],"arg_names":["item_type","min_items","max_items","unique_items"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types.conlist","upper_bound":"builtins.object","values":[],"variance":0}},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"conlist","ret_type":{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types.conlist","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.list"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types.conlist","upper_bound":"builtins.object","values":[],"variance":0}]}}},"conset":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5],"arg_names":["item_type","min_items","max_items"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.types.conset","name":"conset","original_first_arg":"item_type","type":{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":["item_type","min_items","max_items"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types.conset","upper_bound":"builtins.object","values":[],"variance":0}},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"conset","ret_type":{".class":"TypeType","item":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types.conset","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.set"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.types.T","id":-1,"name":"T","namespace":"pydantic.v1.types.conset","upper_bound":"builtins.object","values":[],"variance":0}]}}},"constr":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[5,5,5,5,5,5,5,5],"arg_names":["strip_whitespace","to_upper","to_lower","strict","min_length","max_length","curtail_length","regex"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.types.constr","name":"constr","original_first_arg":"strip_whitespace","type":{".class":"CallableType","arg_kinds":[5,5,5,5,5,5,5,5],"arg_names":["strip_whitespace","to_upper","to_lower","strict","min_length","max_length","curtail_length","regex"],"arg_types":["builtins.bool","builtins.bool","builtins.bool","builtins.bool",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"constr","ret_type":{".class":"TypeType","item":"builtins.str"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"constr_length_validator":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.validators.constr_length_validator","kind":"Gdef","module_public":false},"constr_lower":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.validators.constr_lower","kind":"Gdef","module_public":false},"constr_strip_whitespace":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.validators.constr_strip_whitespace","kind":"Gdef","module_public":false},"constr_upper":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.validators.constr_upper","kind":"Gdef","module_public":false},"date":{".class":"SymbolTableNode","cross_ref":"datetime.date","kind":"Gdef","module_public":false},"decimal_validator":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.validators.decimal_validator","kind":"Gdef","module_public":false},"errors":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors","kind":"Gdef","module_public":false},"float_finite_validator":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.validators.float_finite_validator","kind":"Gdef","module_public":false},"float_validator":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.validators.float_validator","kind":"Gdef","module_public":false},"frozenset_validator":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.validators.frozenset_validator","kind":"Gdef","module_public":false},"import_string":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.import_string","kind":"Gdef","module_public":false},"int_validator":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.validators.int_validator","kind":"Gdef","module_public":false},"list_validator":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.validators.list_validator","kind":"Gdef","module_public":false},"math":{".class":"SymbolTableNode","cross_ref":"math","kind":"Gdef","module_public":false},"new_class":{".class":"SymbolTableNode","cross_ref":"types.new_class","kind":"Gdef","module_public":false},"number_multiple_validator":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.validators.number_multiple_validator","kind":"Gdef","module_public":false},"number_size_validator":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.validators.number_size_validator","kind":"Gdef","module_public":false},"overload":{".class":"SymbolTableNode","cross_ref":"typing.overload","kind":"Gdef","module_public":false},"parse_date":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.datetime_parse.parse_date","kind":"Gdef","module_public":false},"path_exists_validator":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.validators.path_exists_validator","kind":"Gdef","module_public":false},"path_validator":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.validators.path_validator","kind":"Gdef","module_public":false},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef","module_public":false},"set_validator":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.validators.set_validator","kind":"Gdef","module_public":false},"str_validator":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.validators.str_validator","kind":"Gdef","module_public":false},"strict_bytes_validator":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.validators.strict_bytes_validator","kind":"Gdef","module_public":false},"strict_float_validator":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.validators.strict_float_validator","kind":"Gdef","module_public":false},"strict_int_validator":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.validators.strict_int_validator","kind":"Gdef","module_public":false},"strict_str_validator":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.validators.strict_str_validator","kind":"Gdef","module_public":false},"update_not_none":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.update_not_none","kind":"Gdef","module_public":false},"warnings":{".class":"SymbolTableNode","cross_ref":"warnings","kind":"Gdef","module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/types.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/types.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/types.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..0fa000a7c905659d0090a031803cf68e162f9667 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/types.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[31,32,33,34,126,127,128,31,1,2,3,4,5,6,7,8,9,10,28,29,124,1,1,1,1,1,1],"dep_prios":[10,5,5,5,25,25,25,20,10,10,10,10,5,5,5,5,5,5,5,5,25,5,30,30,30,30,30],"dependencies":["pydantic.v1.errors","pydantic.v1.datetime_parse","pydantic.v1.utils","pydantic.v1.validators","pydantic.v1.dataclasses","pydantic.v1.main","pydantic.v1.typing","pydantic.v1","abc","math","re","warnings","datetime","decimal","enum","pathlib","types","typing","uuid","weakref","typing_extensions","builtins","_collections_abc","_frozen_importlib","_typeshed","_weakrefset","os"],"hash":"68499db335d068a7bbd15ed951bfe9338ac16eac","id":"pydantic.v1.types","ignore_all":true,"interface_hash":"2764c87d5b0fa56ef63a7eede21c9a329a99c77c","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/types.py","plugin_data":null,"size":35455,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/typing.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/typing.data.json new file mode 100644 index 0000000000000000000000000000000000000000..a67b22bd713704dd1e0a0ecfbfd18feafdf63955 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/typing.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic.v1.typing","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","AbstractSet":{".class":"SymbolTableNode","cross_ref":"typing.AbstractSet","kind":"Gdef","module_public":false},"AbstractSetIntStr":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.typing.AbstractSetIntStr","line":275,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.IntStr"}],"extra_attrs":null,"type_ref":"typing.AbstractSet"}}},"Annotated":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Annotated","kind":"Gdef","module_public":false},"AnnotatedTypeNames":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.typing.AnnotatedTypeNames","name":"AnnotatedTypeNames","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_public":false},"AnyArgTCallable":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeAlias","alias_tvars":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.typing._T","id":1,"name":"_T","namespace":"pydantic.v1.typing.AnyArgTCallable","upper_bound":"builtins.object","values":[],"variance":0}],"column":0,"fullname":"pydantic.v1.typing.AnyArgTCallable","line":98,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.typing._T","id":1,"name":"_T","namespace":"pydantic.v1.typing.AnyArgTCallable","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"AnyCallable":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic.v1.typing.AnyCallable","line":94,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"AnyClassMethod":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":8,"fullname":"pydantic.v1.typing.AnyClassMethod","line":283,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"builtins.classmethod"}}},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef","module_public":false},"CallableGenerator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.typing.CallableGenerator","line":278,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyCallable"},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Generator"}}},"ClassVar":{".class":"SymbolTableNode","cross_ref":"typing.ClassVar","kind":"Gdef","module_public":false},"Dict":{".class":"SymbolTableNode","cross_ref":"typing.Dict","kind":"Gdef","module_public":false},"DictAny":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.typing.DictAny","line":271,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"DictIntStrAny":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.typing.DictIntStrAny","line":276,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.IntStr"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"DictStrAny":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.typing.DictStrAny","line":270,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"Final":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Final","kind":"Gdef","module_public":false},"ForwardRef":{".class":"SymbolTableNode","cross_ref":"typing.ForwardRef","kind":"Gdef","module_public":false},"Generator":{".class":"SymbolTableNode","cross_ref":"typing.Generator","kind":"Gdef","module_public":false},"IntStr":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.typing.IntStr","line":274,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["builtins.int","builtins.str"],"uses_pep604_syntax":false}}},"Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef","module_public":false},"LITERAL_TYPES":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic.v1.typing.LITERAL_TYPES","name":"LITERAL_TYPES","setter_type":null,"type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.set"}}},"List":{".class":"SymbolTableNode","cross_ref":"typing.List","kind":"Gdef","module_public":false},"ListStr":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.typing.ListStr","line":273,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"Literal":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Literal","kind":"Gdef","module_public":false},"MYPY":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.typing.MYPY","name":"MYPY","setter_type":null,"type":"builtins.bool"}},"Mapping":{".class":"SymbolTableNode","cross_ref":"typing.Mapping","kind":"Gdef","module_public":false},"MappingIntStrAny":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.typing.MappingIntStrAny","line":277,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.IntStr"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Mapping"}}},"ModelField":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.fields.ModelField","kind":"Gdef","module_public":false},"NONE_TYPES":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic.v1.typing.NONE_TYPES","name":"NONE_TYPES","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"NewType":{".class":"SymbolTableNode","cross_ref":"typing.NewType","kind":"Gdef","module_public":false},"NoArgAnyCallable":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic.v1.typing.NoArgAnyCallable","line":95,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"NoneType":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.typing.NoneType","name":"NoneType","setter_type":null,"type":{".class":"TypeType","item":{".class":"NoneType"}}}},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef","module_public":false},"PathLike":{".class":"SymbolTableNode","cross_ref":"os.PathLike","kind":"Gdef","module_public":false},"ReprArgs":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.typing.ReprArgs","line":279,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"typing.Sequence"}}},"Sequence":{".class":"SymbolTableNode","cross_ref":"typing.Sequence","kind":"Gdef","module_public":false},"Set":{".class":"SymbolTableNode","cross_ref":"typing.Set","kind":"Gdef","module_public":false},"SetStr":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.typing.SetStr","line":272,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"StrPath":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"pydantic.v1.typing.StrPath","line":263,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4}],"extra_attrs":null,"type_ref":"os.PathLike"}],"uses_pep604_syntax":false}}},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef","module_public":false},"Tuple":{".class":"SymbolTableNode","cross_ref":"typing.Tuple","kind":"Gdef","module_public":false},"TupleGenerator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.typing.TupleGenerator","line":269,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Generator"}}},"Type":{".class":"SymbolTableNode","cross_ref":"typing.Type","kind":"Gdef","module_public":false},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_public":false},"TypedDictNotRequired":{".class":"SymbolTableNode","cross_ref":"typing_extensions.NotRequired","kind":"Gdef","module_public":false},"TypedDictRequired":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Required","kind":"Gdef","module_public":false},"TypesUnionType":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"pydantic.v1.typing.TypesUnionType","name":"TypesUnionType","setter_type":null,"type":{".class":"AnyType","missing_import_name":"pydantic.v1.typing.TypesUnionType","source_any":null,"type_of_any":3}}},"TypingCallable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef","module_public":false},"TypingGenericAlias":{".class":"SymbolTableNode","cross_ref":"types.GenericAlias","kind":"Gdef","module_public":false},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef","module_public":false},"WithArgsTypes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.typing.WithArgsTypes","name":"WithArgsTypes","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["builtins.type",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.type","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":"GenericAlias","ret_type":"types.GenericAlias","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_T":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.typing._T","name":"_T","upper_bound":"builtins.object","values":[],"variance":0}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.typing.__all__","name":"__all__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.typing.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.typing.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.typing.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.typing.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.typing.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.typing.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_check_classvar":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.typing._check_classvar","name":"_check_classvar","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_check_classvar","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_check_finalvar":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.typing._check_finalvar","name":"_check_finalvar","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_check_finalvar","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_check_typeddict_special":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["type_"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.typing._check_typeddict_special","name":"_check_typeddict_special","original_first_arg":"type_","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["type_"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_check_typeddict_special","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_eval_type":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"pydantic.v1.typing._eval_type","name":"_eval_type","setter_type":null,"type":{".class":"AnyType","missing_import_name":"pydantic.v1.typing._eval_type","source_any":null,"type_of_any":3}}},"_generic_get_args":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["tp"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.typing._generic_get_args","name":"_generic_get_args","original_first_arg":"tp","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["tp"],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_generic_get_args","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_typing_get_args":{".class":"SymbolTableNode","cross_ref":"typing.get_args","kind":"Gdef","module_public":false},"_typing_get_origin":{".class":"SymbolTableNode","cross_ref":"typing.get_origin","kind":"Gdef","module_public":false},"all_literal_values":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["type_"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.typing.all_literal_values","name":"all_literal_values","original_first_arg":"type_","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["type_"],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"all_literal_values","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"cast":{".class":"SymbolTableNode","cross_ref":"typing.cast","kind":"Gdef","module_public":false},"convert_generics":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["tp"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.typing.convert_generics","name":"convert_generics","original_first_arg":"tp","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["tp"],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"convert_generics","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"display_as_type":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.typing.display_as_type","name":"display_as_type","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"display_as_type","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"evaluate_forwardref":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["type_","globalns","localns"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.typing.evaluate_forwardref","name":"evaluate_forwardref","original_first_arg":"type_","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["type_","globalns","localns"],"arg_types":["typing.ForwardRef",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"evaluate_forwardref","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"functools":{".class":"SymbolTableNode","cross_ref":"functools","kind":"Gdef","module_public":false},"get_all_type_hints":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["obj","globalns","localns"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.typing.get_all_type_hints","name":"get_all_type_hints","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["obj","globalns","localns"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_all_type_hints","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_args":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["tp"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.typing.get_args","name":"get_args","original_first_arg":"tp","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["tp"],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_args","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_class":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["type_"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.typing.get_class","name":"get_class","original_first_arg":"type_","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["type_"],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_class","ret_type":{".class":"UnionType","items":[{".class":"NoneType"},"builtins.bool",{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_origin":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["tp"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.typing.get_origin","name":"get_origin","original_first_arg":"tp","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["tp"],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_origin","ret_type":{".class":"UnionType","items":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_sub_types":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["tp"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.typing.get_sub_types","name":"get_sub_types","original_first_arg":"tp","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["tp"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_sub_types","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_type_hints":{".class":"SymbolTableNode","cross_ref":"typing.get_type_hints","kind":"Gdef","module_public":false},"is_callable_type":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["type_"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.typing.is_callable_type","name":"is_callable_type","original_first_arg":"type_","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["type_"],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_callable_type","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_classvar":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["ann_type"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.typing.is_classvar","name":"is_classvar","original_first_arg":"ann_type","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["ann_type"],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_classvar","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_finalvar":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["ann_type"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.typing.is_finalvar","name":"is_finalvar","original_first_arg":"ann_type","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["ann_type"],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_finalvar","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_literal_type":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["type_"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.typing.is_literal_type","name":"is_literal_type","original_first_arg":"type_","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["type_"],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_literal_type","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_namedtuple":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["type_"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.typing.is_namedtuple","name":"is_namedtuple","original_first_arg":"type_","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["type_"],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_namedtuple","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_new_type":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["type_"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.typing.is_new_type","name":"is_new_type","original_first_arg":"type_","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["type_"],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_new_type","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_none_type":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["type_"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.typing.is_none_type","name":"is_none_type","original_first_arg":"type_","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["type_"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_none_type","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_typeddict":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["type_"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.typing.is_typeddict","name":"is_typeddict","original_first_arg":"type_","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["type_"],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_typeddict","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_typeddict_special":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["type_"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.typing.is_typeddict_special","name":"is_typeddict_special","original_first_arg":"type_","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["type_"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_typeddict_special","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_union":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["tp"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.typing.is_union","name":"is_union","original_first_arg":"tp","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["tp"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_union","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"literal_values":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["type_"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.typing.literal_values","name":"literal_values","original_first_arg":"type_","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["type_"],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"literal_values","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"new_type_supertype":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["type_"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.typing.new_type_supertype","name":"new_type_supertype","original_first_arg":"type_","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["type_"],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"new_type_supertype","ret_type":{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"operator":{".class":"SymbolTableNode","cross_ref":"operator","kind":"Gdef","module_public":false},"resolve_annotations":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["raw_annotations","module_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.typing.resolve_annotations","name":"resolve_annotations","original_first_arg":"raw_annotations","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["raw_annotations","module_name"],"arg_types":[{".class":"Instance","args":["builtins.str",{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"resolve_annotations","ret_type":{".class":"Instance","args":["builtins.str",{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"sys":{".class":"SymbolTableNode","cross_ref":"sys","kind":"Gdef","module_public":false},"test_type":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.str"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.typing.test_type","name":"test_type","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_newtype"],"fullname":"pydantic.v1.typing.test_type","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.typing","mro":["pydantic.v1.typing.test_type","builtins.str","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","item"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.typing.test_type.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","item"],"arg_types":["pydantic.v1.typing.test_type","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of test_type","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef","module_public":false},"typing_base":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"pydantic.v1.typing.typing_base","name":"typing_base","setter_type":null,"type":{".class":"AnyType","missing_import_name":"pydantic.v1.typing.typing_base","source_any":null,"type_of_any":3}}},"update_field_forward_refs":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["field","globalns","localns"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.typing.update_field_forward_refs","name":"update_field_forward_refs","original_first_arg":"field","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["field","globalns","localns"],"arg_types":["pydantic.v1.fields.ModelField",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"update_field_forward_refs","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"update_model_forward_refs":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,1],"arg_names":["model","fields","json_encoders","localns","exc_to_suppress"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.typing.update_model_forward_refs","name":"update_model_forward_refs","original_first_arg":"model","type":{".class":"CallableType","arg_kinds":[0,0,0,0,1],"arg_names":["model","fields","json_encoders","localns","exc_to_suppress"],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},{".class":"Instance","args":["pydantic.v1.fields.ModelField"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},"builtins.str","typing.ForwardRef"],"uses_pep604_syntax":false},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyCallable"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.DictStrAny"},{".class":"Instance","args":[{".class":"TypeType","item":"builtins.BaseException"}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"update_model_forward_refs","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/typing.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/typing.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/typing.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..04bd789f213cad5772a5a38bb17a3b29dc6df266 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/typing.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[267,5,1,2,3,4,6,32,52,1,1,1,1,1],"dep_prios":[25,5,10,10,10,5,5,5,5,5,30,30,30,30],"dependencies":["pydantic.v1.fields","collections.abc","functools","operator","sys","typing","os","typing_extensions","types","builtins","_frozen_importlib","_typeshed","abc","pydantic.v1.utils"],"hash":"9cb9647e59ab8cb320ad96b7f15e36a567cd00f4","id":"pydantic.v1.typing","ignore_all":true,"interface_hash":"86ff86eb14a90d35ee312ff505872457515e23ef","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/typing.py","plugin_data":null,"size":19677,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/utils.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/utils.data.json new file mode 100644 index 0000000000000000000000000000000000000000..ebdd8c7eb202d403099481fbaf37665684b24ec4 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/utils.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic.v1.utils","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","AbstractSet":{".class":"SymbolTableNode","cross_ref":"typing.AbstractSet","kind":"Gdef","module_public":false},"AbstractSetIntStr":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.AbstractSetIntStr","kind":"Gdef","module_public":false},"Annotated":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Annotated","kind":"Gdef","module_public":false},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef","module_public":false},"BUILTIN_COLLECTIONS":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic.v1.utils.BUILTIN_COLLECTIONS","name":"BUILTIN_COLLECTIONS","setter_type":null,"type":{".class":"Instance","args":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"extra_attrs":null,"type_ref":"builtins.set"}}},"BaseConfig":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.config.BaseConfig","kind":"Gdef","module_public":false},"BaseModel":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.main.BaseModel","kind":"Gdef","module_public":false},"BuiltinFunctionType":{".class":"SymbolTableNode","cross_ref":"types.BuiltinFunctionType","kind":"Gdef","module_public":false},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef","module_public":false},"ClassAttribute":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.utils.ClassAttribute","name":"ClassAttribute","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.utils.ClassAttribute","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.utils","mro":["pydantic.v1.utils.ClassAttribute","builtins.object"],"names":{".class":"SymbolTable","__get__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","instance","owner"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.utils.ClassAttribute.__get__","name":"__get__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","instance","owner"],"arg_types":["pydantic.v1.utils.ClassAttribute",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__get__ of ClassAttribute","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","name","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.utils.ClassAttribute.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","name","value"],"arg_types":["pydantic.v1.utils.ClassAttribute","builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of ClassAttribute","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic.v1.utils.ClassAttribute.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"name":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.utils.ClassAttribute.name","name":"name","setter_type":null,"type":"builtins.str"}},"value":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.utils.ClassAttribute.value","name":"value","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.utils.ClassAttribute.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.utils.ClassAttribute","values":[],"variance":0},"slots":["name","value"],"tuple_type":null,"type_vars":[],"typeddict_type":null}},"CodeType":{".class":"SymbolTableNode","cross_ref":"types.CodeType","kind":"Gdef","module_public":false},"Collection":{".class":"SymbolTableNode","cross_ref":"typing.Collection","kind":"Gdef","module_public":false},"ConfigError":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors.ConfigError","kind":"Gdef","module_public":false},"DUNDER_ATTRIBUTES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.utils.DUNDER_ATTRIBUTES","name":"DUNDER_ATTRIBUTES","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"Dataclass":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.dataclasses.Dataclass","kind":"Gdef","module_public":false},"Dict":{".class":"SymbolTableNode","cross_ref":"typing.Dict","kind":"Gdef","module_public":false},"DictIntStrAny":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.DictIntStrAny","kind":"Gdef","module_public":false},"FunctionType":{".class":"SymbolTableNode","cross_ref":"types.FunctionType","kind":"Gdef","module_public":false},"Generator":{".class":"SymbolTableNode","cross_ref":"typing.Generator","kind":"Gdef","module_public":false},"GeneratorType":{".class":"SymbolTableNode","cross_ref":"types.GeneratorType","kind":"Gdef","module_public":false},"GetterDict":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.utils.Representation"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.utils.GetterDict","name":"GetterDict","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.utils.GetterDict","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.utils","mro":["pydantic.v1.utils.GetterDict","pydantic.v1.utils.Representation","builtins.object"],"names":{".class":"SymbolTable","__contains__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.utils.GetterDict.__contains__","name":"__contains__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["pydantic.v1.utils.GetterDict",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__contains__ of GetterDict","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__eq__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.utils.GetterDict.__eq__","name":"__eq__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["pydantic.v1.utils.GetterDict",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__eq__ of GetterDict","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__getitem__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.utils.GetterDict.__getitem__","name":"__getitem__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["pydantic.v1.utils.GetterDict","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__getitem__ of GetterDict","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.utils.GetterDict.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","obj"],"arg_types":["pydantic.v1.utils.GetterDict",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of GetterDict","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__iter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.utils.GetterDict.__iter__","name":"__iter__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["pydantic.v1.utils.GetterDict"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iter__ of GetterDict","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Iterator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__len__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.utils.GetterDict.__len__","name":"__len__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["pydantic.v1.utils.GetterDict"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__len__ of GetterDict","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr_args__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.utils.GetterDict.__repr_args__","name":"__repr_args__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.utils.GetterDict"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr_args__ of GetterDict","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.ReprArgs"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr_name__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.utils.GetterDict.__repr_name__","name":"__repr_name__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.utils.GetterDict"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr_name__ of GetterDict","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic.v1.utils.GetterDict.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_obj":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.utils.GetterDict._obj","name":"_obj","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"extra_keys":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.utils.GetterDict.extra_keys","name":"extra_keys","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.utils.GetterDict"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"extra_keys of GetterDict","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.set"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","key","default"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.utils.GetterDict.get","name":"get","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","key","default"],"arg_types":["pydantic.v1.utils.GetterDict",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get of GetterDict","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"items":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.utils.GetterDict.items","name":"items","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.utils.GetterDict"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"items of GetterDict","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"typing.Iterator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"keys":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.utils.GetterDict.keys","name":"keys","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.utils.GetterDict"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"keys of GetterDict","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"values":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.utils.GetterDict.values","name":"values","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.utils.GetterDict"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"values of GetterDict","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.utils.GetterDict.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.utils.GetterDict","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"IMMUTABLE_NON_COLLECTIONS_TYPES":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic.v1.utils.IMMUTABLE_NON_COLLECTIONS_TYPES","name":"IMMUTABLE_NON_COLLECTIONS_TYPES","setter_type":null,"type":{".class":"Instance","args":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"extra_attrs":null,"type_ref":"builtins.set"}}},"IntStr":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.IntStr","kind":"Gdef","module_public":false},"Iterable":{".class":"SymbolTableNode","cross_ref":"typing.Iterable","kind":"Gdef","module_public":false},"Iterator":{".class":"SymbolTableNode","cross_ref":"typing.Iterator","kind":"Gdef","module_public":false},"KeyType":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.utils.KeyType","name":"KeyType","upper_bound":"builtins.object","values":[],"variance":0}},"LambdaType":{".class":"SymbolTableNode","cross_ref":"types.LambdaType","kind":"Gdef","module_public":false},"List":{".class":"SymbolTableNode","cross_ref":"typing.List","kind":"Gdef","module_public":false},"Mapping":{".class":"SymbolTableNode","cross_ref":"typing.Mapping","kind":"Gdef","module_public":false},"MappingIntStrAny":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.MappingIntStrAny","kind":"Gdef","module_public":false},"ModelField":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.fields.ModelField","kind":"Gdef","module_public":false},"ModuleType":{".class":"SymbolTableNode","cross_ref":"types.ModuleType","kind":"Gdef","module_public":false},"NoReturn":{".class":"SymbolTableNode","cross_ref":"typing.NoReturn","kind":"Gdef","module_public":false},"NoneType":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.NoneType","kind":"Gdef","module_public":false},"Obj":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.utils.Obj","name":"Obj","upper_bound":"builtins.object","values":[],"variance":0}},"Optional":{".class":"SymbolTableNode","cross_ref":"typing.Optional","kind":"Gdef","module_public":false},"OrderedDict":{".class":"SymbolTableNode","cross_ref":"collections.OrderedDict","kind":"Gdef","module_public":false},"Path":{".class":"SymbolTableNode","cross_ref":"pathlib.Path","kind":"Gdef","module_public":false},"PyObjectStr":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.str"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.utils.PyObjectStr","name":"PyObjectStr","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.utils.PyObjectStr","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"pydantic.v1.utils","mro":["pydantic.v1.utils.PyObjectStr","builtins.str","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.utils.PyObjectStr.__repr__","name":"__repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["pydantic.v1.utils.PyObjectStr"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr__ of PyObjectStr","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.utils.PyObjectStr.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.utils.PyObjectStr","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"ROOT_KEY":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.utils.ROOT_KEY","name":"ROOT_KEY","setter_type":null,"type":"builtins.str"}},"ReprArgs":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.ReprArgs","kind":"Gdef","module_public":false},"Representation":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.utils.Representation","name":"Representation","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.utils.Representation","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.utils","mro":["pydantic.v1.utils.Representation","builtins.object"],"names":{".class":"SymbolTable","__pretty__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,4],"arg_names":["self","fmt","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.utils.Representation.__pretty__","name":"__pretty__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,4],"arg_names":["self","fmt","kwargs"],"arg_types":["pydantic.v1.utils.Representation",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__pretty__ of Representation","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Generator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.utils.Representation.__repr__","name":"__repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["pydantic.v1.utils.Representation"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr__ of Representation","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr_args__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.utils.Representation.__repr_args__","name":"__repr_args__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.utils.Representation"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr_args__ of Representation","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.ReprArgs"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr_name__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.utils.Representation.__repr_name__","name":"__repr_name__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.utils.Representation"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr_name__ of Representation","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr_str__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","join_str"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.utils.Representation.__repr_str__","name":"__repr_str__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","join_str"],"arg_types":["pydantic.v1.utils.Representation","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr_str__ of Representation","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__rich_repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.utils.Representation.__rich_repr__","name":"__rich_repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.utils.Representation"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__rich_repr__ of Representation","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.utils.RichReprResult"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic.v1.utils.Representation.__slots__","name":"__slots__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}}},"__str__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.utils.Representation.__str__","name":"__str__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["pydantic.v1.utils.Representation"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__str__ of Representation","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.utils.Representation.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.utils.Representation","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"RichReprResult":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.utils.RichReprResult","line":54,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"TupleType","implicit":false,"items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TupleType","implicit":false,"items":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"typing.Iterable"}}},"Set":{".class":"SymbolTableNode","cross_ref":"typing.Set","kind":"Gdef","module_public":false},"Signature":{".class":"SymbolTableNode","cross_ref":"inspect.Signature","kind":"Gdef","module_public":false},"T":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.utils.T","name":"T","upper_bound":"builtins.object","values":[],"variance":0}},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef","module_public":false},"Tuple":{".class":"SymbolTableNode","cross_ref":"typing.Tuple","kind":"Gdef","module_public":false},"Type":{".class":"SymbolTableNode","cross_ref":"typing.Type","kind":"Gdef","module_public":false},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef","module_public":false},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef","module_public":false},"ValueItems":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["pydantic.v1.utils.Representation"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.utils.ValueItems","name":"ValueItems","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.utils.ValueItems","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.utils","mro":["pydantic.v1.utils.ValueItems","pydantic.v1.utils.Representation","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","value","items"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.utils.ValueItems.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","value","items"],"arg_types":["pydantic.v1.utils.ValueItems",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AbstractSetIntStr"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.MappingIntStrAny"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of ValueItems","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr_args__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.utils.ValueItems.__repr_args__","name":"__repr_args__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["pydantic.v1.utils.ValueItems"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr_args__ of ValueItems","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.ReprArgs"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"pydantic.v1.utils.ValueItems.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_coerce_items":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["items"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"pydantic.v1.utils.ValueItems._coerce_items","name":"_coerce_items","original_first_arg":"items","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["items"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AbstractSetIntStr"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.MappingIntStrAny"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_coerce_items of ValueItems","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.MappingIntStrAny"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_staticmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.utils.ValueItems._coerce_items","name":"_coerce_items","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["items"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AbstractSetIntStr"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.MappingIntStrAny"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_coerce_items of ValueItems","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.MappingIntStrAny"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"_coerce_value":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.utils.ValueItems._coerce_value","name":"_coerce_value","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","value"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.utils.ValueItems"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_coerce_value of ValueItems","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.utils.ValueItems._coerce_value","name":"_coerce_value","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","value"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.utils.ValueItems"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_coerce_value of ValueItems","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"_items":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"pydantic.v1.utils.ValueItems._items","name":"_items","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.MappingIntStrAny"}}},"_normalize_indexes":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","items","v_length"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.utils.ValueItems._normalize_indexes","name":"_normalize_indexes","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","items","v_length"],"arg_types":["pydantic.v1.utils.ValueItems",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.MappingIntStrAny"},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_normalize_indexes of ValueItems","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.DictIntStrAny"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"for_element":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","e"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.utils.ValueItems.for_element","name":"for_element","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","e"],"arg_types":["pydantic.v1.utils.ValueItems",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.IntStr"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"for_element of ValueItems","ret_type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AbstractSetIntStr"},{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.MappingIntStrAny"},{".class":"NoneType"}],"uses_pep604_syntax":false},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_excluded":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","item"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.utils.ValueItems.is_excluded","name":"is_excluded","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","item"],"arg_types":["pydantic.v1.utils.ValueItems",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_excluded of ValueItems","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_included":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","item"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.utils.ValueItems.is_included","name":"is_included","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","item"],"arg_types":["pydantic.v1.utils.ValueItems",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_included of ValueItems","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_true":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"pydantic.v1.utils.ValueItems.is_true","name":"is_true","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_true of ValueItems","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_staticmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.utils.ValueItems.is_true","name":"is_true","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_true of ValueItems","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"merge":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["cls","base","override","intersect"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"pydantic.v1.utils.ValueItems.merge","name":"merge","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["cls","base","override","intersect"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.utils.ValueItems"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"merge of ValueItems","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"pydantic.v1.utils.ValueItems.merge","name":"merge","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["cls","base","override","intersect"],"arg_types":[{".class":"TypeType","item":"pydantic.v1.utils.ValueItems"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"merge of ValueItems","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.utils.ValueItems.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.utils.ValueItems","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"WithArgsTypes":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.WithArgsTypes","kind":"Gdef","module_public":false},"_EMPTY":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.utils._EMPTY","name":"_EMPTY","setter_type":null,"type":"builtins.object"}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.utils.__all__","name":"__all__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.utils.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.utils.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.utils.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.utils.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.utils.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.utils.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_get_union_alias_and_all_values":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["union_type","discriminator_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.utils._get_union_alias_and_all_values","name":"_get_union_alias_and_all_values","original_first_arg":"union_type","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["union_type","discriminator_key"],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_get_union_alias_and_all_values","ret_type":{".class":"TupleType","implicit":false,"items":["builtins.str",{".class":"Instance","args":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"all_identical":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["left","right"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.utils.all_identical","name":"all_identical","original_first_arg":"left","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["left","right"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"all_identical","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"all_literal_values":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.all_literal_values","kind":"Gdef","module_public":false},"almost_equal_floats":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,5],"arg_names":["value_1","value_2","delta"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.utils.almost_equal_floats","name":"almost_equal_floats","original_first_arg":"value_1","type":{".class":"CallableType","arg_kinds":[0,0,5],"arg_names":["value_1","value_2","delta"],"arg_types":["builtins.float","builtins.float","builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"almost_equal_floats","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"assert_never":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["obj","msg"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.utils.assert_never","name":"assert_never","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["obj","msg"],"arg_types":[{".class":"UninhabitedType"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_never","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"deep_update":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2],"arg_names":["mapping","updating_mappings"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.utils.deep_update","name":"deep_update","original_first_arg":"mapping","type":{".class":"CallableType","arg_kinds":[0,2],"arg_names":["mapping","updating_mappings"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.utils.KeyType","id":-1,"name":"KeyType","namespace":"pydantic.v1.utils.deep_update","upper_bound":"builtins.object","values":[],"variance":0},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.utils.KeyType","id":-1,"name":"KeyType","namespace":"pydantic.v1.utils.deep_update","upper_bound":"builtins.object","values":[],"variance":0},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"deep_update","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.utils.KeyType","id":-1,"name":"KeyType","namespace":"pydantic.v1.utils.deep_update","upper_bound":"builtins.object","values":[],"variance":0},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.utils.KeyType","id":-1,"name":"KeyType","namespace":"pydantic.v1.utils.deep_update","upper_bound":"builtins.object","values":[],"variance":0}]}}},"deepcopy":{".class":"SymbolTableNode","cross_ref":"copy.deepcopy","kind":"Gdef","module_public":false},"defaultdict":{".class":"SymbolTableNode","cross_ref":"collections.defaultdict","kind":"Gdef","module_public":false},"deque":{".class":"SymbolTableNode","cross_ref":"collections.deque","kind":"Gdef","module_public":false},"display_as_type":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.display_as_type","kind":"Gdef","module_public":false},"generate_model_signature":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["init","fields","config"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.utils.generate_model_signature","name":"generate_model_signature","original_first_arg":"init","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["init","fields","config"],"arg_types":[{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"Instance","args":["builtins.str","pydantic.v1.fields.ModelField"],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"TypeType","item":"pydantic.v1.config.BaseConfig"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"generate_model_signature","ret_type":"inspect.Signature","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_args":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.get_args","kind":"Gdef","module_public":false},"get_discriminator_alias_and_values":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["tp","discriminator_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.utils.get_discriminator_alias_and_values","name":"get_discriminator_alias_and_values","original_first_arg":"tp","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["tp","discriminator_key"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_discriminator_alias_and_values","ret_type":{".class":"TupleType","implicit":false,"items":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_model":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.utils.get_model","name":"get_model","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeType","item":"pydantic.v1.main.BaseModel"},{".class":"TypeType","item":"pydantic.v1.dataclasses.Dataclass"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_model","ret_type":{".class":"TypeType","item":"pydantic.v1.main.BaseModel"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_origin":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.get_origin","kind":"Gdef","module_public":false},"get_unique_discriminator_alias":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["all_aliases","discriminator_key"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.utils.get_unique_discriminator_alias","name":"get_unique_discriminator_alias","original_first_arg":"all_aliases","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["all_aliases","discriminator_key"],"arg_types":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Collection"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_unique_discriminator_alias","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"import_string":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["dotted_path"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.utils.import_string","name":"import_string","original_first_arg":"dotted_path","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["dotted_path"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"import_string","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"in_ipython":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.utils.in_ipython","name":"in_ipython","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"in_ipython","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_literal_type":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.is_literal_type","kind":"Gdef","module_public":false},"is_union":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.is_union","kind":"Gdef","module_public":false},"is_valid_field":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.utils.is_valid_field","name":"is_valid_field","original_first_arg":"name","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["name"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_valid_field","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_valid_identifier":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["identifier"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.utils.is_valid_identifier","name":"is_valid_identifier","original_first_arg":"identifier","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["identifier"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_valid_identifier","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_valid_private_name":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.utils.is_valid_private_name","name":"is_valid_private_name","original_first_arg":"name","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["name"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_valid_private_name","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"islice":{".class":"SymbolTableNode","cross_ref":"itertools.islice","kind":"Gdef","module_public":false},"keyword":{".class":"SymbolTableNode","cross_ref":"keyword","kind":"Gdef","module_public":false},"lenient_isinstance":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["o","class_or_tuple"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.utils.lenient_isinstance","name":"lenient_isinstance","original_first_arg":"o","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["o","class_or_tuple"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},{".class":"Instance","args":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lenient_isinstance","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"lenient_issubclass":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","class_or_tuple"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.utils.lenient_issubclass","name":"lenient_issubclass","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","class_or_tuple"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},{".class":"Instance","args":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"lenient_issubclass","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"path_type":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["p"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.utils.path_type","name":"path_type","original_first_arg":"p","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["p"],"arg_types":["pathlib.Path"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"path_type","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"path_types":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.utils.path_types","name":"path_types","setter_type":null,"type":{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"sequence_like":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.utils.sequence_like","name":"sequence_like","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sequence_like","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"smart_deepcopy":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.utils.smart_deepcopy","name":"smart_deepcopy","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.utils.Obj","id":-1,"name":"Obj","namespace":"pydantic.v1.utils.smart_deepcopy","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"smart_deepcopy","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.utils.Obj","id":-1,"name":"Obj","namespace":"pydantic.v1.utils.smart_deepcopy","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.utils.Obj","id":-1,"name":"Obj","namespace":"pydantic.v1.utils.smart_deepcopy","upper_bound":"builtins.object","values":[],"variance":0}]}}},"to_camel":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["string"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.utils.to_camel","name":"to_camel","original_first_arg":"string","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["string"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"to_camel","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"to_lower_camel":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["string"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.utils.to_lower_camel","name":"to_lower_camel","original_first_arg":"string","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["string"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"to_lower_camel","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"truncate":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5],"arg_names":["v","max_len"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.utils.truncate","name":"truncate","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0,5],"arg_names":["v","max_len"],"arg_types":["builtins.str","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"truncate","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"unique_list":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5],"arg_names":["input_list","name_factory"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.utils.unique_list","name":"unique_list","original_first_arg":"input_list","type":{".class":"CallableType","arg_kinds":[0,5],"arg_names":["input_list","name_factory"],"arg_types":[{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.utils.T","id":-1,"name":"T","namespace":"pydantic.v1.utils.unique_list","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.utils.T","id":-1,"name":"T","namespace":"pydantic.v1.utils.unique_list","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"uses_pep604_syntax":false},{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.utils.T","id":-1,"name":"T","namespace":"pydantic.v1.utils.unique_list","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unique_list","ret_type":{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.utils.T","id":-1,"name":"T","namespace":"pydantic.v1.utils.unique_list","upper_bound":"builtins.object","values":[],"variance":0}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.utils.T","id":-1,"name":"T","namespace":"pydantic.v1.utils.unique_list","upper_bound":"builtins.object","values":[],"variance":0}]}}},"update_not_none":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,4],"arg_names":["mapping","update"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.utils.update_not_none","name":"update_not_none","original_first_arg":"mapping","type":{".class":"CallableType","arg_kinds":[0,4],"arg_names":["mapping","update"],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"update_not_none","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"validate_field_name":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["bases","field_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.utils.validate_field_name","name":"validate_field_name","original_first_arg":"bases","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["bases","field_name"],"arg_types":[{".class":"Instance","args":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}],"extra_attrs":null,"type_ref":"typing.Iterable"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate_field_name","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"version_info":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.version.version_info","kind":"Gdef"},"warnings":{".class":"SymbolTableNode","cross_ref":"warnings","kind":"Gdef","module_public":false},"weakref":{".class":"SymbolTableNode","cross_ref":"weakref","kind":"Gdef","module_public":false},"zip_longest":{".class":"SymbolTableNode","cross_ref":"itertools.zip_longest","kind":"Gdef","module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/utils.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/utils.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/utils.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..4d312ee49e64f1aec181a6b832f4dde5b06844c8 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/utils.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[31,32,42,48,49,50,51,1,2,3,4,5,6,7,8,29,45,46,1,1,1,1,1],"dep_prios":[5,5,5,25,25,25,25,10,10,10,5,5,5,5,5,5,25,25,5,30,30,30,30],"dependencies":["pydantic.v1.errors","pydantic.v1.typing","pydantic.v1.version","pydantic.v1.config","pydantic.v1.dataclasses","pydantic.v1.fields","pydantic.v1.main","keyword","warnings","weakref","collections","copy","itertools","types","typing","typing_extensions","inspect","pathlib","builtins","_frozen_importlib","_typeshed","abc","os"],"hash":"31ea8335d088cc55bfeb6a2339aaaba04941c94d","id":"pydantic.v1.utils","ignore_all":true,"interface_hash":"3944045b41c0ad4e1f38d8f2875f4221c41e286d","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/utils.py","plugin_data":null,"size":25989,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/validators.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/validators.data.json new file mode 100644 index 0000000000000000000000000000000000000000..3e5030cde9f42f69d606ad14e22e73055963c0f7 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/validators.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic.v1.validators","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"AnyCallable":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.AnyCallable","kind":"Gdef"},"AnyOrderedDict":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.validators.AnyOrderedDict","line":55,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"collections.OrderedDict"}}},"BOOL_FALSE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.validators.BOOL_FALSE","name":"BOOL_FALSE","setter_type":null,"type":{".class":"Instance","args":["builtins.object"],"extra_attrs":null,"type_ref":"builtins.set"}}},"BOOL_TRUE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.validators.BOOL_TRUE","name":"BOOL_TRUE","setter_type":null,"type":{".class":"Instance","args":["builtins.object"],"extra_attrs":null,"type_ref":"builtins.set"}}},"BaseConfig":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.config.BaseConfig","kind":"Gdef"},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"CollectionsHashable":{".class":"SymbolTableNode","cross_ref":"typing.Hashable","kind":"Gdef"},"ConstrainedDecimal":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.ConstrainedDecimal","kind":"Gdef"},"ConstrainedFloat":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.ConstrainedFloat","kind":"Gdef"},"ConstrainedInt":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.types.ConstrainedInt","kind":"Gdef"},"ConstrainedNumber":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.validators.ConstrainedNumber","line":54,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["pydantic.v1.types.ConstrainedDecimal","pydantic.v1.types.ConstrainedFloat","pydantic.v1.types.ConstrainedInt"],"uses_pep604_syntax":false}}},"Decimal":{".class":"SymbolTableNode","cross_ref":"decimal.Decimal","kind":"Gdef"},"DecimalException":{".class":"SymbolTableNode","cross_ref":"decimal.DecimalException","kind":"Gdef"},"Deque":{".class":"SymbolTableNode","cross_ref":"typing.Deque","kind":"Gdef"},"Dict":{".class":"SymbolTableNode","cross_ref":"typing.Dict","kind":"Gdef"},"Enum":{".class":"SymbolTableNode","cross_ref":"enum.Enum","kind":"Gdef"},"ForwardRef":{".class":"SymbolTableNode","cross_ref":"typing.ForwardRef","kind":"Gdef"},"FrozenSet":{".class":"SymbolTableNode","cross_ref":"typing.FrozenSet","kind":"Gdef"},"Generator":{".class":"SymbolTableNode","cross_ref":"typing.Generator","kind":"Gdef"},"Hashable":{".class":"SymbolTableNode","cross_ref":"typing.Hashable","kind":"Gdef"},"IPv4Address":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv4Address","kind":"Gdef"},"IPv4Interface":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv4Interface","kind":"Gdef"},"IPv4Network":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv4Network","kind":"Gdef"},"IPv6Address":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv6Address","kind":"Gdef"},"IPv6Interface":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv6Interface","kind":"Gdef"},"IPv6Network":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv6Network","kind":"Gdef"},"IfConfig":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"pydantic.v1.validators.IfConfig","name":"IfConfig","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.IfConfig","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"pydantic.v1.validators","mro":["pydantic.v1.validators.IfConfig","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,2,5],"arg_names":["self","validator","config_attr_names","ignored_value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.validators.IfConfig.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,2,5],"arg_names":["self","validator","config_attr_names","ignored_value"],"arg_types":["pydantic.v1.validators.IfConfig",{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyCallable"},"builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of IfConfig","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"check":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","config"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"pydantic.v1.validators.IfConfig.check","name":"check","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","config"],"arg_types":["pydantic.v1.validators.IfConfig",{".class":"TypeType","item":"pydantic.v1.config.BaseConfig"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"check of IfConfig","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"config_attr_names":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.validators.IfConfig.config_attr_names","name":"config_attr_names","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.tuple"}}},"ignored_value":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.validators.IfConfig.ignored_value","name":"ignored_value","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"validator":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"pydantic.v1.validators.IfConfig.validator","name":"validator","setter_type":null,"type":{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.validators.IfConfig.Self","id":0,"name":"Self","namespace":"","upper_bound":"pydantic.v1.validators.IfConfig","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"IntEnum":{".class":"SymbolTableNode","cross_ref":"enum.IntEnum","kind":"Gdef"},"List":{".class":"SymbolTableNode","cross_ref":"typing.List","kind":"Gdef"},"Literal":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Literal","kind":"Gdef"},"ModelField":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.fields.ModelField","kind":"Gdef"},"NamedTuple":{".class":"SymbolTableNode","cross_ref":"typing.NamedTuple","kind":"Gdef"},"NamedTupleT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.validators.NamedTupleT","name":"NamedTupleT","upper_bound":"typing.NamedTuple","values":[],"variance":0}},"Number":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.validators.Number","line":56,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["builtins.int","builtins.float","decimal.Decimal"],"uses_pep604_syntax":false}}},"OrderedDict":{".class":"SymbolTableNode","cross_ref":"collections.OrderedDict","kind":"Gdef"},"Path":{".class":"SymbolTableNode","cross_ref":"pathlib.Path","kind":"Gdef"},"Pattern":{".class":"SymbolTableNode","cross_ref":"re.Pattern","kind":"Gdef"},"Set":{".class":"SymbolTableNode","cross_ref":"typing.Set","kind":"Gdef"},"StrBytes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":4,"fullname":"pydantic.v1.validators.StrBytes","line":57,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["builtins.str","builtins.bytes"],"uses_pep604_syntax":false}}},"T":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.validators.T","name":"T","upper_bound":"builtins.object","values":[],"variance":0}},"TYPE_CHECKING":{".class":"SymbolTableNode","cross_ref":"typing.TYPE_CHECKING","kind":"Gdef"},"Tuple":{".class":"SymbolTableNode","cross_ref":"typing.Tuple","kind":"Gdef"},"Type":{".class":"SymbolTableNode","cross_ref":"typing.Type","kind":"Gdef"},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef"},"TypedDict":{".class":"SymbolTableNode","cross_ref":"typing.TypedDict","kind":"Gdef"},"UUID":{".class":"SymbolTableNode","cross_ref":"uuid.UUID","kind":"Gdef"},"Union":{".class":"SymbolTableNode","cross_ref":"typing.Union","kind":"Gdef"},"_VALIDATORS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic.v1.validators._VALIDATORS","name":"_VALIDATORS","setter_type":null,"type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.validators.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.validators.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.validators.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.validators.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.validators.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.validators.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"all_literal_values":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.all_literal_values","kind":"Gdef"},"almost_equal_floats":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.almost_equal_floats","kind":"Gdef"},"any_class_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.any_class_validator","name":"any_class_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"any_class_validator","ret_type":{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.validators.T","id":-1,"name":"T","namespace":"pydantic.v1.validators.any_class_validator","upper_bound":"builtins.object","values":[],"variance":0}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.validators.T","id":-1,"name":"T","namespace":"pydantic.v1.validators.any_class_validator","upper_bound":"builtins.object","values":[],"variance":0}]}}},"anystr_length_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["v","config"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.anystr_length_validator","name":"anystr_length_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["v","config"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.validators.StrBytes"},"pydantic.v1.config.BaseConfig"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"anystr_length_validator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.validators.StrBytes"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"anystr_lower":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.anystr_lower","name":"anystr_lower","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.validators.StrBytes"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"anystr_lower","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.validators.StrBytes"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"anystr_strip_whitespace":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.anystr_strip_whitespace","name":"anystr_strip_whitespace","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.validators.StrBytes"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"anystr_strip_whitespace","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.validators.StrBytes"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"anystr_upper":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.anystr_upper","name":"anystr_upper","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.validators.StrBytes"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"anystr_upper","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.validators.StrBytes"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"bool_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.bool_validator","name":"bool_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"bool_validator","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"bytes_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.bytes_validator","name":"bytes_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"bytes_validator","ret_type":"builtins.bytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"callable_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.callable_validator","name":"callable_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"callable_validator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyCallable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"constant_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["v","field"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.constant_validator","name":"constant_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["v","field"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"pydantic.v1.fields.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"constant_validator","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"constr_length_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["v","field","config"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.constr_length_validator","name":"constr_length_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["v","field","config"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.validators.StrBytes"},"pydantic.v1.fields.ModelField","pydantic.v1.config.BaseConfig"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"constr_length_validator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.validators.StrBytes"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"constr_lower":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["v","field","config"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.constr_lower","name":"constr_lower","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["v","field","config"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.validators.StrBytes"},"pydantic.v1.fields.ModelField","pydantic.v1.config.BaseConfig"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"constr_lower","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.validators.StrBytes"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"constr_strip_whitespace":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["v","field","config"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.constr_strip_whitespace","name":"constr_strip_whitespace","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["v","field","config"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.validators.StrBytes"},"pydantic.v1.fields.ModelField","pydantic.v1.config.BaseConfig"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"constr_strip_whitespace","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.validators.StrBytes"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"constr_upper":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["v","field","config"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.constr_upper","name":"constr_upper","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["v","field","config"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.validators.StrBytes"},"pydantic.v1.fields.ModelField","pydantic.v1.config.BaseConfig"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"constr_upper","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.validators.StrBytes"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"date":{".class":"SymbolTableNode","cross_ref":"datetime.date","kind":"Gdef"},"datetime":{".class":"SymbolTableNode","cross_ref":"datetime.datetime","kind":"Gdef"},"decimal_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.decimal_validator","name":"decimal_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"decimal_validator","ret_type":"decimal.Decimal","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"deque":{".class":"SymbolTableNode","cross_ref":"collections.deque","kind":"Gdef"},"deque_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.deque_validator","name":"deque_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"deque_validator","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"collections.deque"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"dict_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.dict_validator","name":"dict_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dict_validator","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"display_as_type":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.display_as_type","kind":"Gdef"},"enum_member_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["v","field","config"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.enum_member_validator","name":"enum_member_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["v","field","config"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"pydantic.v1.fields.ModelField","pydantic.v1.config.BaseConfig"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"enum_member_validator","ret_type":"enum.Enum","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"enum_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.enum_validator","name":"enum_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"enum_validator","ret_type":"enum.Enum","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"errors":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.errors","kind":"Gdef"},"find_validators":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["type_","config"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.find_validators","name":"find_validators","original_first_arg":"type_","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["type_","config"],"arg_types":[{".class":"TypeType","item":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}},{".class":"TypeType","item":"pydantic.v1.config.BaseConfig"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"find_validators","ret_type":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.typing.AnyCallable"},{".class":"NoneType"},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Generator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"float_finite_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["v","field","config"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.float_finite_validator","name":"float_finite_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["v","field","config"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.validators.Number"},"pydantic.v1.fields.ModelField","pydantic.v1.config.BaseConfig"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"float_finite_validator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.validators.Number"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"float_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.float_validator","name":"float_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"float_validator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"frozenset_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.frozenset_validator","name":"frozenset_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"frozenset_validator","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.frozenset"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_class":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.get_class","kind":"Gdef"},"hashable_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.hashable_validator","name":"hashable_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hashable_validator","ret_type":"typing.Hashable","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"int_enum_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.int_enum_validator","name":"int_enum_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"int_enum_validator","ret_type":"enum.IntEnum","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"int_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.int_validator","name":"int_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"int_validator","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"ip_v4_address_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.ip_v4_address_validator","name":"ip_v4_address_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ip_v4_address_validator","ret_type":"ipaddress.IPv4Address","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"ip_v4_interface_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.ip_v4_interface_validator","name":"ip_v4_interface_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ip_v4_interface_validator","ret_type":"ipaddress.IPv4Interface","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"ip_v4_network_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.ip_v4_network_validator","name":"ip_v4_network_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ip_v4_network_validator","ret_type":"ipaddress.IPv4Network","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"ip_v6_address_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.ip_v6_address_validator","name":"ip_v6_address_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ip_v6_address_validator","ret_type":"ipaddress.IPv6Address","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"ip_v6_interface_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.ip_v6_interface_validator","name":"ip_v6_interface_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ip_v6_interface_validator","ret_type":"ipaddress.IPv6Interface","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"ip_v6_network_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.ip_v6_network_validator","name":"ip_v6_network_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ip_v6_network_validator","ret_type":"ipaddress.IPv6Network","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_callable_type":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.is_callable_type","kind":"Gdef"},"is_literal_type":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.is_literal_type","kind":"Gdef"},"is_namedtuple":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.is_namedtuple","kind":"Gdef"},"is_none_type":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.is_none_type","kind":"Gdef"},"is_typeddict":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.typing.is_typeddict","kind":"Gdef"},"lenient_issubclass":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.lenient_issubclass","kind":"Gdef"},"list_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.list_validator","name":"list_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"list_validator","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"make_arbitrary_type_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["type_"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.make_arbitrary_type_validator","name":"make_arbitrary_type_validator","original_first_arg":"type_","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["type_"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.validators.T","id":-1,"name":"T","namespace":"pydantic.v1.validators.make_arbitrary_type_validator","upper_bound":"builtins.object","values":[],"variance":0}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"make_arbitrary_type_validator","ret_type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.validators.T","id":-1,"name":"T","namespace":"pydantic.v1.validators.make_arbitrary_type_validator","upper_bound":"builtins.object","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.validators.T","id":-1,"name":"T","namespace":"pydantic.v1.validators.make_arbitrary_type_validator","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.validators.T","id":-1,"name":"T","namespace":"pydantic.v1.validators.make_arbitrary_type_validator","upper_bound":"builtins.object","values":[],"variance":0}]}}},"make_class_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["type_"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.make_class_validator","name":"make_class_validator","original_first_arg":"type_","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["type_"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.validators.T","id":-1,"name":"T","namespace":"pydantic.v1.validators.make_class_validator","upper_bound":"builtins.object","values":[],"variance":0}}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"make_class_validator","ret_type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.validators.T","id":-1,"name":"T","namespace":"pydantic.v1.validators.make_class_validator","upper_bound":"builtins.object","values":[],"variance":0}},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.validators.T","id":-1,"name":"T","namespace":"pydantic.v1.validators.make_class_validator","upper_bound":"builtins.object","values":[],"variance":0}]}}},"make_literal_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["type_"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.make_literal_validator","name":"make_literal_validator","original_first_arg":"type_","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["type_"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"make_literal_validator","ret_type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"make_namedtuple_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["namedtuple_cls","config"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.make_namedtuple_validator","name":"make_namedtuple_validator","original_first_arg":"namedtuple_cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["namedtuple_cls","config"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.validators.NamedTupleT","id":-1,"name":"NamedTupleT","namespace":"pydantic.v1.validators.make_namedtuple_validator","upper_bound":"typing.NamedTuple","values":[],"variance":0}},{".class":"TypeType","item":"pydantic.v1.config.BaseConfig"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"make_namedtuple_validator","ret_type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.validators.NamedTupleT","id":-1,"name":"NamedTupleT","namespace":"pydantic.v1.validators.make_namedtuple_validator","upper_bound":"typing.NamedTuple","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"pydantic.v1.validators.NamedTupleT","id":-1,"name":"NamedTupleT","namespace":"pydantic.v1.validators.make_namedtuple_validator","upper_bound":"typing.NamedTuple","values":[],"variance":0}]}}},"make_typeddict_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["typeddict_cls","config"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.make_typeddict_validator","name":"make_typeddict_validator","original_first_arg":"typeddict_cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["typeddict_cls","config"],"arg_types":[{".class":"TypeType","item":{".class":"UnboundType","args":[],"expr":"TypedDict","expr_fallback":"builtins.str","name":"TypedDict"}},{".class":"TypeType","item":"pydantic.v1.config.BaseConfig"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"make_typeddict_validator","ret_type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"math":{".class":"SymbolTableNode","cross_ref":"math","kind":"Gdef"},"max_str_int":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.validators.max_str_int","name":"max_str_int","setter_type":null,"type":"builtins.int"}},"none_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.none_validator","name":"none_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"none_validator","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"number_multiple_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["v","field"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.number_multiple_validator","name":"number_multiple_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["v","field"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.validators.Number"},"pydantic.v1.fields.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"number_multiple_validator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.validators.Number"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"number_size_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["v","field"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.number_size_validator","name":"number_size_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["v","field"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.validators.Number"},"pydantic.v1.fields.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"number_size_validator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.validators.Number"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"ordered_dict_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.ordered_dict_validator","name":"ordered_dict_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ordered_dict_validator","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"pydantic.v1.validators.AnyOrderedDict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"parse_date":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.datetime_parse.parse_date","kind":"Gdef"},"parse_datetime":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.datetime_parse.parse_datetime","kind":"Gdef"},"parse_duration":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.datetime_parse.parse_duration","kind":"Gdef"},"parse_time":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.datetime_parse.parse_time","kind":"Gdef"},"path_exists_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.path_exists_validator","name":"path_exists_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"path_exists_validator","ret_type":"pathlib.Path","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"path_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.path_validator","name":"path_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"path_validator","ret_type":"pathlib.Path","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"pattern_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.pattern_validator","name":"pattern_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"pattern_validator","ret_type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef"},"sequence_like":{".class":"SymbolTableNode","cross_ref":"pydantic.v1.utils.sequence_like","kind":"Gdef"},"set_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.set_validator","name":"set_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"set_validator","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.set"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"str_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.str_validator","name":"str_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"str_validator","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"strict_bytes_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.strict_bytes_validator","name":"strict_bytes_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strict_bytes_validator","ret_type":"builtins.bytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"strict_float_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.strict_float_validator","name":"strict_float_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strict_float_validator","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"strict_int_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.strict_int_validator","name":"strict_int_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strict_int_validator","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"strict_str_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.strict_str_validator","name":"strict_str_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"strict_str_validator","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"time":{".class":"SymbolTableNode","cross_ref":"datetime.time","kind":"Gdef"},"timedelta":{".class":"SymbolTableNode","cross_ref":"datetime.timedelta","kind":"Gdef"},"tuple_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["v"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.tuple_validator","name":"tuple_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["v"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"tuple_validator","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.tuple"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"uuid_validator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["v","field"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.uuid_validator","name":"uuid_validator","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["v","field"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"pydantic.v1.fields.ModelField"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"uuid_validator","ret_type":"uuid.UUID","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"validate_json":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["v","config"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.validators.validate_json","name":"validate_json","original_first_arg":"v","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["v","config"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"pydantic.v1.config.BaseConfig"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"validate_json","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"warn":{".class":"SymbolTableNode","cross_ref":"_warnings.warn","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/validators.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/validators.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/validators.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..ac614c9cda784fe5ca7358b3035524c63a6df8fb --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/validators.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[32,33,34,45,50,51,52,4,32,1,2,3,5,6,7,8,9,10,29,30,48,1,1,1,1,1],"dep_prios":[10,5,5,5,25,25,25,5,20,10,10,5,5,5,5,5,5,5,5,5,25,5,30,30,30,30],"dependencies":["pydantic.v1.errors","pydantic.v1.datetime_parse","pydantic.v1.typing","pydantic.v1.utils","pydantic.v1.config","pydantic.v1.fields","pydantic.v1.types","collections.abc","pydantic.v1","math","re","collections","datetime","decimal","enum","ipaddress","pathlib","typing","uuid","warnings","typing_extensions","builtins","_frozen_importlib","_typeshed","abc","os"],"hash":"5c800a071f8e038cf9b23f0717d1ffcaa1b79968","id":"pydantic.v1.validators","ignore_all":true,"interface_hash":"118cc343a55f0b37b199e1fcb2a0dcfc5ffa8772","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/validators.py","plugin_data":null,"size":22187,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/version.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/version.data.json new file mode 100644 index 0000000000000000000000000000000000000000..b8aad94e30e1f2455dc99192a526c626edd41012 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/version.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"pydantic.v1.version","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","VERSION":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.version.VERSION","name":"VERSION","setter_type":null,"type":"builtins.str"}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"pydantic.v1.version.__all__","name":"__all__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.version.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.version.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.version.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.version.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.version.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"pydantic.v1.version.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"compiled":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"pydantic.v1.version.compiled","name":"compiled","setter_type":null,"type":"builtins.bool"}},"cython":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"pydantic.v1.version.cython","name":"cython","setter_type":null,"type":{".class":"AnyType","missing_import_name":"pydantic.v1.version.cython","source_any":null,"type_of_any":3}}},"version_info":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"pydantic.v1.version.version_info","name":"version_info","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"version_info","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/version.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/version.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/version.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..35be01028cf1f4545cd3f0419c71595f4c7ac1d4 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/pydantic/v1/version.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106713,"dep_lines":[1,1,1,1,6],"dep_prios":[5,30,30,30,10],"dependencies":["builtins","_frozen_importlib","abc","typing"],"hash":"c4ca52fa2039b548d1740b47825f4967a7d83ad5","id":"pydantic.v1.version","ignore_all":true,"interface_hash":"78d0d336ff664c4955665a8bda46cc8b689c20ce","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/pydantic/v1/version.py","plugin_data":null,"size":1039,"suppressed":["cython"],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/starlette/middleware/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/starlette/middleware/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..18b87ed8e7cba7b2ed111b52f3b63c40c2633c1a --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/starlette/middleware/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"starlette.middleware","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"Awaitable":{".class":"SymbolTableNode","cross_ref":"typing.Awaitable","kind":"Gdef"},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"Iterator":{".class":"SymbolTableNode","cross_ref":"typing.Iterator","kind":"Gdef"},"Middleware":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"starlette.middleware.Middleware","name":"Middleware","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"starlette.middleware.Middleware","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"starlette.middleware","mro":["starlette.middleware.Middleware","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,2,4],"arg_names":["self","cls","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"starlette.middleware.Middleware.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,2,4],"arg_names":["self","cls","args","kwargs"],"arg_types":["starlette.middleware.Middleware","starlette.middleware._MiddlewareFactory",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of Middleware","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__iter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"starlette.middleware.Middleware.__iter__","name":"__iter__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["starlette.middleware.Middleware"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__iter__ of Middleware","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Iterator"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"starlette.middleware.Middleware.__repr__","name":"__repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["starlette.middleware.Middleware"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr__ of Middleware","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"args":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"starlette.middleware.Middleware.args","name":"args","setter_type":null,"type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}},"cls":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"starlette.middleware.Middleware.cls","name":"cls","setter_type":null,"type":"starlette.middleware._MiddlewareFactory"}},"kwargs":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"starlette.middleware.Middleware.kwargs","name":"kwargs","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"starlette.middleware.Middleware.Self","id":0,"name":"Self","namespace":"","upper_bound":"starlette.middleware.Middleware","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"P":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"starlette.middleware.P","name":"P","setter_type":null,"type":{".class":"AnyType","missing_import_name":"starlette.middleware.ParamSpec","source_any":{".class":"AnyType","missing_import_name":"starlette.middleware.ParamSpec","source_any":null,"type_of_any":3},"type_of_any":7}}},"ParamSpec":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"starlette.middleware.ParamSpec","name":"ParamSpec","setter_type":null,"type":{".class":"AnyType","missing_import_name":"starlette.middleware.ParamSpec","source_any":null,"type_of_any":3}}},"Protocol":{".class":"SymbolTableNode","cross_ref":"typing.Protocol","kind":"Gdef"},"_ASGIApp":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"starlette.middleware._ASGIApp","line":14,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,null,null],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"starlette.middleware._Scope"},{".class":"TypeAliasType","args":[],"type_ref":"starlette.middleware._Receive"},{".class":"TypeAliasType","args":[],"type_ref":"starlette.middleware._Send"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":[{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Awaitable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_MiddlewareFactory":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[["__call__",2]],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"starlette.middleware._MiddlewareFactory","name":"_MiddlewareFactory","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_abstract","is_protocol"],"fullname":"starlette.middleware._MiddlewareFactory","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"starlette.middleware","mro":["starlette.middleware._MiddlewareFactory","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":2,"arg_kinds":[0,0,2,4],"arg_names":[null,null,"args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_body","is_trivial_self"],"fullname":"starlette.middleware._MiddlewareFactory.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,2,4],"arg_names":[null,null,"args","kwargs"],"arg_types":["starlette.middleware._MiddlewareFactory",{".class":"TypeAliasType","args":[],"type_ref":"starlette.middleware._ASGIApp"},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _MiddlewareFactory","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"starlette.middleware._ASGIApp"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"starlette.middleware._MiddlewareFactory.Self","id":0,"name":"Self","namespace":"","upper_bound":"starlette.middleware._MiddlewareFactory","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_Receive":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"starlette.middleware._Receive","line":10,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Awaitable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_Scope":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"starlette.middleware._Scope","line":9,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}}},"_Send":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"starlette.middleware._Send","line":11,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":[{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Awaitable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"starlette.middleware.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"starlette.middleware.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"starlette.middleware.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"starlette.middleware.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"starlette.middleware.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"starlette.middleware.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"starlette.middleware.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/starlette/middleware/__init__.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/starlette/middleware/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/starlette/middleware/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..cdb600e4361ac8722cb8cb56fa80959ebbdafb1e --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/starlette/middleware/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106714,"dep_lines":[3,1,4,1,1,1],"dep_prios":[5,5,5,5,30,30],"dependencies":["collections.abc","__future__","typing","builtins","_frozen_importlib","abc"],"hash":"7115d516c47888f2d2a83295ae5e1dad0ca9ae68","id":"starlette.middleware","ignore_all":true,"interface_hash":"8afeb9984865e88047e6475bf043ffb27c6663b4","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/starlette/middleware/__init__.py","plugin_data":null,"size":1349,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/starlette/middleware/base.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/starlette/middleware/base.data.json new file mode 100644 index 0000000000000000000000000000000000000000..b582e8fff7b5d8f543052d5ae899f3cb15b0dac8 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/starlette/middleware/base.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"starlette.middleware.base","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","ASGIApp":{".class":"SymbolTableNode","cross_ref":"starlette.types.ASGIApp","kind":"Gdef"},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"AsyncContentStream":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"starlette.middleware.base.AsyncContentStream","name":"AsyncContentStream","setter_type":null,"type":"types.GenericAlias"}},"AsyncGenerator":{".class":"SymbolTableNode","cross_ref":"typing.AsyncGenerator","kind":"Gdef"},"AsyncIterable":{".class":"SymbolTableNode","cross_ref":"typing.AsyncIterable","kind":"Gdef"},"Awaitable":{".class":"SymbolTableNode","cross_ref":"typing.Awaitable","kind":"Gdef"},"BaseHTTPMiddleware":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"starlette.middleware.base.BaseHTTPMiddleware","name":"BaseHTTPMiddleware","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"starlette.middleware.base.BaseHTTPMiddleware","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"starlette.middleware.base","mro":["starlette.middleware.base.BaseHTTPMiddleware","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","scope","receive","send"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"starlette.middleware.base.BaseHTTPMiddleware.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","scope","receive","send"],"arg_types":["starlette.middleware.base.BaseHTTPMiddleware",{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Scope"},{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Receive"},{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Send"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of BaseHTTPMiddleware","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","app","dispatch"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"starlette.middleware.base.BaseHTTPMiddleware.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","app","dispatch"],"arg_types":["starlette.middleware.base.BaseHTTPMiddleware",{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.ASGIApp"},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"starlette.middleware.base.DispatchFunction"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of BaseHTTPMiddleware","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"app":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"starlette.middleware.base.BaseHTTPMiddleware.app","name":"app","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,null,null],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Scope"},{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Receive"},{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Send"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":[{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Awaitable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"dispatch":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","request","call_next"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"starlette.middleware.base.BaseHTTPMiddleware.dispatch","name":"dispatch","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","request","call_next"],"arg_types":["starlette.middleware.base.BaseHTTPMiddleware","starlette.requests.Request",{".class":"TypeAliasType","args":[],"type_ref":"starlette.middleware.base.RequestResponseEndpoint"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"dispatch of BaseHTTPMiddleware","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"starlette.responses.Response"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"dispatch_func":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"starlette.middleware.base.BaseHTTPMiddleware.dispatch_func","name":"dispatch_func","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["starlette.requests.Request",{".class":"TypeAliasType","args":[],"type_ref":"starlette.middleware.base.RequestResponseEndpoint"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":["starlette.responses.Response"],"extra_attrs":null,"type_ref":"typing.Awaitable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"starlette.middleware.base.BaseHTTPMiddleware.Self","id":0,"name":"Self","namespace":"","upper_bound":"starlette.middleware.base.BaseHTTPMiddleware","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"BodyStreamGenerator":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"starlette.middleware.base.BodyStreamGenerator","name":"BodyStreamGenerator","setter_type":null,"type":"types.GenericAlias"}},"Callable":{".class":"SymbolTableNode","cross_ref":"typing.Callable","kind":"Gdef"},"ClientDisconnect":{".class":"SymbolTableNode","cross_ref":"starlette.requests.ClientDisconnect","kind":"Gdef"},"DispatchFunction":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"starlette.middleware.base.DispatchFunction","line":14,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["starlette.requests.Request",{".class":"TypeAliasType","args":[],"type_ref":"starlette.middleware.base.RequestResponseEndpoint"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":["starlette.responses.Response"],"extra_attrs":null,"type_ref":"typing.Awaitable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"Mapping":{".class":"SymbolTableNode","cross_ref":"typing.Mapping","kind":"Gdef"},"Message":{".class":"SymbolTableNode","cross_ref":"starlette.types.Message","kind":"Gdef"},"MutableMapping":{".class":"SymbolTableNode","cross_ref":"typing.MutableMapping","kind":"Gdef"},"Receive":{".class":"SymbolTableNode","cross_ref":"starlette.types.Receive","kind":"Gdef"},"Request":{".class":"SymbolTableNode","cross_ref":"starlette.requests.Request","kind":"Gdef"},"RequestResponseEndpoint":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"starlette.middleware.base.RequestResponseEndpoint","line":13,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["starlette.requests.Request"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":["starlette.responses.Response"],"extra_attrs":null,"type_ref":"typing.Awaitable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"Response":{".class":"SymbolTableNode","cross_ref":"starlette.responses.Response","kind":"Gdef"},"Scope":{".class":"SymbolTableNode","cross_ref":"starlette.types.Scope","kind":"Gdef"},"Send":{".class":"SymbolTableNode","cross_ref":"starlette.types.Send","kind":"Gdef"},"T":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"starlette.middleware.base.T","name":"T","upper_bound":"builtins.object","values":[],"variance":0}},"TypeVar":{".class":"SymbolTableNode","cross_ref":"typing.TypeVar","kind":"Gdef"},"_CachedRequest":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["starlette.requests.Request"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"starlette.middleware.base._CachedRequest","name":"_CachedRequest","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"starlette.middleware.base._CachedRequest","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"starlette.middleware.base","mro":["starlette.middleware.base._CachedRequest","starlette.requests.Request","starlette.requests.HTTPConnection","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","scope","receive"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"starlette.middleware.base._CachedRequest.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","scope","receive"],"arg_types":["starlette.middleware.base._CachedRequest",{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Scope"},{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Receive"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of _CachedRequest","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_wrapped_rc_stream":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"starlette.middleware.base._CachedRequest._wrapped_rc_stream","name":"_wrapped_rc_stream","setter_type":null,"type":{".class":"Instance","args":["builtins.bytes",{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.AsyncGenerator"}}},"_wrapped_rcv_consumed":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"starlette.middleware.base._CachedRequest._wrapped_rcv_consumed","name":"_wrapped_rcv_consumed","setter_type":null,"type":"builtins.bool"}},"_wrapped_rcv_disconnected":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"starlette.middleware.base._CachedRequest._wrapped_rcv_disconnected","name":"_wrapped_rcv_disconnected","setter_type":null,"type":"builtins.bool"}},"wrapped_receive":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"starlette.middleware.base._CachedRequest.wrapped_receive","name":"wrapped_receive","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["starlette.middleware.base._CachedRequest"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"wrapped_receive of _CachedRequest","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Message"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"starlette.middleware.base._CachedRequest.Self","id":0,"name":"Self","namespace":"","upper_bound":"starlette.middleware.base._CachedRequest","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_StreamingResponse":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["starlette.responses.Response"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"starlette.middleware.base._StreamingResponse","name":"_StreamingResponse","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"starlette.middleware.base._StreamingResponse","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"starlette.middleware.base","mro":["starlette.middleware.base._StreamingResponse","starlette.responses.Response","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","scope","receive","send"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"starlette.middleware.base._StreamingResponse.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","scope","receive","send"],"arg_types":["starlette.middleware.base._StreamingResponse",{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Scope"},{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Receive"},{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Send"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of _StreamingResponse","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1],"arg_names":["self","content","status_code","headers","media_type","info"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"starlette.middleware.base._StreamingResponse.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["self","content","status_code","headers","media_type","info"],"arg_types":["starlette.middleware.base._StreamingResponse",{".class":"UnboundType","args":[],"expr":null,"expr_fallback":null,"name":"AsyncContentStream"},"builtins.int",{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of _StreamingResponse","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"body_iterator":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"starlette.middleware.base._StreamingResponse.body_iterator","name":"body_iterator","setter_type":null,"type":{".class":"UnboundType","args":[],"expr":null,"expr_fallback":null,"name":"AsyncContentStream"}}},"info":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"starlette.middleware.base._StreamingResponse.info","name":"info","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"NoneType"}],"uses_pep604_syntax":true}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"starlette.middleware.base._StreamingResponse.Self","id":0,"name":"Self","namespace":"","upper_bound":"starlette.middleware.base._StreamingResponse","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"starlette.middleware.base.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"starlette.middleware.base.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"starlette.middleware.base.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"starlette.middleware.base.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"starlette.middleware.base.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"starlette.middleware.base.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"anyio":{".class":"SymbolTableNode","cross_ref":"anyio","kind":"Gdef"},"collapse_excgroups":{".class":"SymbolTableNode","cross_ref":"starlette._utils.collapse_excgroups","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/starlette/middleware/base.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/starlette/middleware/base.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/starlette/middleware/base.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..a7fb92ed055f416c31d5d03e8c19dcf065f65da6 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/starlette/middleware/base.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[3,8,9,10,11,1,4,6,1,1,1,1,1,1],"dep_prios":[5,5,5,5,5,5,5,10,5,30,30,30,30,30],"dependencies":["collections.abc","starlette._utils","starlette.requests","starlette.responses","starlette.types","__future__","typing","anyio","builtins","_frozen_importlib","abc","starlette.background","types","typing_extensions"],"hash":"8e05667ef34a2159c079d6836f07c8d60b61e8fe","id":"starlette.middleware.base","ignore_all":true,"interface_hash":"128e4b594f0cd0b2165cb10b9cb6585e95b74558","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/starlette/middleware/base.py","plugin_data":null,"size":10333,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/starlette/middleware/errors.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/starlette/middleware/errors.data.json new file mode 100644 index 0000000000000000000000000000000000000000..70c6b03a2dc5c777c16d830fb18ae662ebf9ae44 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/starlette/middleware/errors.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"starlette.middleware.errors","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","ASGIApp":{".class":"SymbolTableNode","cross_ref":"starlette.types.ASGIApp","kind":"Gdef"},"CENTER_LINE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"starlette.middleware.errors.CENTER_LINE","name":"CENTER_LINE","setter_type":null,"type":"builtins.str"}},"ExceptionHandler":{".class":"SymbolTableNode","cross_ref":"starlette.types.ExceptionHandler","kind":"Gdef"},"FRAME_TEMPLATE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"starlette.middleware.errors.FRAME_TEMPLATE","name":"FRAME_TEMPLATE","setter_type":null,"type":"builtins.str"}},"HTMLResponse":{".class":"SymbolTableNode","cross_ref":"starlette.responses.HTMLResponse","kind":"Gdef"},"JS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"starlette.middleware.errors.JS","name":"JS","setter_type":null,"type":"builtins.str"}},"LINE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"starlette.middleware.errors.LINE","name":"LINE","setter_type":null,"type":"builtins.str"}},"Message":{".class":"SymbolTableNode","cross_ref":"starlette.types.Message","kind":"Gdef"},"PlainTextResponse":{".class":"SymbolTableNode","cross_ref":"starlette.responses.PlainTextResponse","kind":"Gdef"},"Receive":{".class":"SymbolTableNode","cross_ref":"starlette.types.Receive","kind":"Gdef"},"Request":{".class":"SymbolTableNode","cross_ref":"starlette.requests.Request","kind":"Gdef"},"Response":{".class":"SymbolTableNode","cross_ref":"starlette.responses.Response","kind":"Gdef"},"STYLES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"starlette.middleware.errors.STYLES","name":"STYLES","setter_type":null,"type":"builtins.str"}},"Scope":{".class":"SymbolTableNode","cross_ref":"starlette.types.Scope","kind":"Gdef"},"Send":{".class":"SymbolTableNode","cross_ref":"starlette.types.Send","kind":"Gdef"},"ServerErrorMiddleware":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"starlette.middleware.errors.ServerErrorMiddleware","name":"ServerErrorMiddleware","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"starlette.middleware.errors.ServerErrorMiddleware","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"starlette.middleware.errors","mro":["starlette.middleware.errors.ServerErrorMiddleware","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","scope","receive","send"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"starlette.middleware.errors.ServerErrorMiddleware.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","scope","receive","send"],"arg_types":["starlette.middleware.errors.ServerErrorMiddleware",{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Scope"},{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Receive"},{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Send"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of ServerErrorMiddleware","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","app","handler","debug"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"starlette.middleware.errors.ServerErrorMiddleware.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","app","handler","debug"],"arg_types":["starlette.middleware.errors.ServerErrorMiddleware",{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.ASGIApp"},{".class":"UnionType","items":[{".class":"UnboundType","args":[],"expr":null,"expr_fallback":null,"name":"ExceptionHandler"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of ServerErrorMiddleware","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"app":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"starlette.middleware.errors.ServerErrorMiddleware.app","name":"app","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,null,null],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Scope"},{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Receive"},{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Send"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":[{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Awaitable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"debug":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"starlette.middleware.errors.ServerErrorMiddleware.debug","name":"debug","setter_type":null,"type":"builtins.bool"}},"debug_response":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","request","exc"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"starlette.middleware.errors.ServerErrorMiddleware.debug_response","name":"debug_response","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","request","exc"],"arg_types":["starlette.middleware.errors.ServerErrorMiddleware","starlette.requests.Request","builtins.Exception"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"debug_response of ServerErrorMiddleware","ret_type":"starlette.responses.Response","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"error_response":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","request","exc"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"starlette.middleware.errors.ServerErrorMiddleware.error_response","name":"error_response","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","request","exc"],"arg_types":["starlette.middleware.errors.ServerErrorMiddleware","starlette.requests.Request","builtins.Exception"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"error_response of ServerErrorMiddleware","ret_type":"starlette.responses.Response","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"format_line":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0],"arg_names":["self","index","line","frame_lineno","frame_index"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"starlette.middleware.errors.ServerErrorMiddleware.format_line","name":"format_line","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":["self","index","line","frame_lineno","frame_index"],"arg_types":["starlette.middleware.errors.ServerErrorMiddleware","builtins.int","builtins.str","builtins.int","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"format_line of ServerErrorMiddleware","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"generate_frame_html":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","frame","is_collapsed"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"starlette.middleware.errors.ServerErrorMiddleware.generate_frame_html","name":"generate_frame_html","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","frame","is_collapsed"],"arg_types":["starlette.middleware.errors.ServerErrorMiddleware",{".class":"TypeAliasType","args":[],"type_ref":"inspect.FrameInfo"},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"generate_frame_html of ServerErrorMiddleware","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"generate_html":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","exc","limit"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"starlette.middleware.errors.ServerErrorMiddleware.generate_html","name":"generate_html","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","exc","limit"],"arg_types":["starlette.middleware.errors.ServerErrorMiddleware","builtins.Exception","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"generate_html of ServerErrorMiddleware","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"generate_plain_text":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","exc"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"starlette.middleware.errors.ServerErrorMiddleware.generate_plain_text","name":"generate_plain_text","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","exc"],"arg_types":["starlette.middleware.errors.ServerErrorMiddleware","builtins.Exception"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"generate_plain_text of ServerErrorMiddleware","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"handler":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"starlette.middleware.errors.ServerErrorMiddleware.handler","name":"handler","setter_type":null,"type":{".class":"UnionType","items":[{".class":"UnboundType","args":[],"expr":null,"expr_fallback":null,"name":"ExceptionHandler"},{".class":"NoneType"}],"uses_pep604_syntax":true}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"starlette.middleware.errors.ServerErrorMiddleware.Self","id":0,"name":"Self","namespace":"","upper_bound":"starlette.middleware.errors.ServerErrorMiddleware","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TEMPLATE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"starlette.middleware.errors.TEMPLATE","name":"TEMPLATE","setter_type":null,"type":"builtins.str"}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"starlette.middleware.errors.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"starlette.middleware.errors.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"starlette.middleware.errors.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"starlette.middleware.errors.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"starlette.middleware.errors.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"starlette.middleware.errors.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"html":{".class":"SymbolTableNode","cross_ref":"html","kind":"Gdef"},"inspect":{".class":"SymbolTableNode","cross_ref":"inspect","kind":"Gdef"},"is_async_callable":{".class":"SymbolTableNode","cross_ref":"starlette._utils.is_async_callable","kind":"Gdef"},"run_in_threadpool":{".class":"SymbolTableNode","cross_ref":"starlette.concurrency.run_in_threadpool","kind":"Gdef"},"sys":{".class":"SymbolTableNode","cross_ref":"sys","kind":"Gdef"},"traceback":{".class":"SymbolTableNode","cross_ref":"traceback","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/starlette/middleware/errors.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/starlette/middleware/errors.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/starlette/middleware/errors.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..6bae4cb0e3361e5466d0cba6804e0c1669e4febc --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/starlette/middleware/errors.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[8,9,10,11,12,1,3,4,5,6,1,1,1,1,1],"dep_prios":[5,5,5,5,5,5,10,10,10,10,5,30,30,30,30],"dependencies":["starlette._utils","starlette.concurrency","starlette.requests","starlette.responses","starlette.types","__future__","html","inspect","sys","traceback","builtins","_frozen_importlib","abc","types","typing"],"hash":"37792ce495db97f0ca9fa640f329ddfb7ac34e14","id":"starlette.middleware.errors","ignore_all":true,"interface_hash":"00556ddb1bd5d3dffc659fa541a94ebca2a30098","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/starlette/middleware/errors.py","plugin_data":null,"size":8037,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/starlette/middleware/exceptions.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/starlette/middleware/exceptions.data.json new file mode 100644 index 0000000000000000000000000000000000000000..c77e3dada5fa5cb4c55a8415ed08fdc3c34626aa --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/starlette/middleware/exceptions.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"starlette.middleware.exceptions","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","ASGIApp":{".class":"SymbolTableNode","cross_ref":"starlette.types.ASGIApp","kind":"Gdef"},"Any":{".class":"SymbolTableNode","cross_ref":"typing.Any","kind":"Gdef"},"ExceptionHandler":{".class":"SymbolTableNode","cross_ref":"starlette.types.ExceptionHandler","kind":"Gdef"},"ExceptionHandlers":{".class":"SymbolTableNode","cross_ref":"starlette._exception_handler.ExceptionHandlers","kind":"Gdef"},"ExceptionMiddleware":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"starlette.middleware.exceptions.ExceptionMiddleware","name":"ExceptionMiddleware","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"starlette.middleware.exceptions.ExceptionMiddleware","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"starlette.middleware.exceptions","mro":["starlette.middleware.exceptions.ExceptionMiddleware","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","scope","receive","send"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"starlette.middleware.exceptions.ExceptionMiddleware.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","scope","receive","send"],"arg_types":["starlette.middleware.exceptions.ExceptionMiddleware",{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Scope"},{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Receive"},{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Send"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of ExceptionMiddleware","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","app","handlers","debug"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"starlette.middleware.exceptions.ExceptionMiddleware.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","app","handlers","debug"],"arg_types":["starlette.middleware.exceptions.ExceptionMiddleware",{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.ASGIApp"},{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnboundType","args":[],"expr":null,"expr_fallback":null,"name":"ExceptionHandler"}],"extra_attrs":null,"type_ref":"typing.Mapping"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of ExceptionMiddleware","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_exception_handlers":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"starlette.middleware.exceptions.ExceptionMiddleware._exception_handlers","name":"_exception_handlers","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"starlette._exception_handler.ExceptionHandlers"}}},"_status_handlers":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"starlette.middleware.exceptions.ExceptionMiddleware._status_handlers","name":"_status_handlers","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"starlette._exception_handler.StatusHandlers"}}},"add_exception_handler":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","exc_class_or_status_code","handler"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"starlette.middleware.exceptions.ExceptionMiddleware.add_exception_handler","name":"add_exception_handler","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","exc_class_or_status_code","handler"],"arg_types":["starlette.middleware.exceptions.ExceptionMiddleware",{".class":"UnionType","items":["builtins.int",{".class":"TypeType","item":"builtins.Exception"}],"uses_pep604_syntax":true},{".class":"UnboundType","args":[],"expr":null,"expr_fallback":null,"name":"ExceptionHandler"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"add_exception_handler of ExceptionMiddleware","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"app":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"starlette.middleware.exceptions.ExceptionMiddleware.app","name":"app","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,null,null],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Scope"},{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Receive"},{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Send"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":[{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Awaitable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"debug":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"starlette.middleware.exceptions.ExceptionMiddleware.debug","name":"debug","setter_type":null,"type":"builtins.bool"}},"http_exception":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","request","exc"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"starlette.middleware.exceptions.ExceptionMiddleware.http_exception","name":"http_exception","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","request","exc"],"arg_types":["starlette.middleware.exceptions.ExceptionMiddleware","starlette.requests.Request","builtins.Exception"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"http_exception of ExceptionMiddleware","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},"starlette.responses.Response"],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"websocket_exception":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","websocket","exc"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"starlette.middleware.exceptions.ExceptionMiddleware.websocket_exception","name":"websocket_exception","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","websocket","exc"],"arg_types":["starlette.middleware.exceptions.ExceptionMiddleware","starlette.websockets.WebSocket","builtins.Exception"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"websocket_exception of ExceptionMiddleware","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"starlette.middleware.exceptions.ExceptionMiddleware.Self","id":0,"name":"Self","namespace":"","upper_bound":"starlette.middleware.exceptions.ExceptionMiddleware","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"HTTPException":{".class":"SymbolTableNode","cross_ref":"starlette.exceptions.HTTPException","kind":"Gdef"},"Mapping":{".class":"SymbolTableNode","cross_ref":"typing.Mapping","kind":"Gdef"},"PlainTextResponse":{".class":"SymbolTableNode","cross_ref":"starlette.responses.PlainTextResponse","kind":"Gdef"},"Receive":{".class":"SymbolTableNode","cross_ref":"starlette.types.Receive","kind":"Gdef"},"Request":{".class":"SymbolTableNode","cross_ref":"starlette.requests.Request","kind":"Gdef"},"Response":{".class":"SymbolTableNode","cross_ref":"starlette.responses.Response","kind":"Gdef"},"Scope":{".class":"SymbolTableNode","cross_ref":"starlette.types.Scope","kind":"Gdef"},"Send":{".class":"SymbolTableNode","cross_ref":"starlette.types.Send","kind":"Gdef"},"StatusHandlers":{".class":"SymbolTableNode","cross_ref":"starlette._exception_handler.StatusHandlers","kind":"Gdef"},"WebSocket":{".class":"SymbolTableNode","cross_ref":"starlette.websockets.WebSocket","kind":"Gdef"},"WebSocketException":{".class":"SymbolTableNode","cross_ref":"starlette.exceptions.WebSocketException","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"starlette.middleware.exceptions.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"starlette.middleware.exceptions.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"starlette.middleware.exceptions.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"starlette.middleware.exceptions.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"starlette.middleware.exceptions.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"starlette.middleware.exceptions.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"wrap_app_handling_exceptions":{".class":"SymbolTableNode","cross_ref":"starlette._exception_handler.wrap_app_handling_exceptions","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/starlette/middleware/exceptions.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/starlette/middleware/exceptions.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/starlette/middleware/exceptions.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..d7ed37166ef9e085ed1c09c3dd7f507e0ceb2386 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/starlette/middleware/exceptions.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[3,6,11,12,13,14,15,1,4,1,1,1],"dep_prios":[5,5,5,5,5,5,5,5,5,5,30,30],"dependencies":["collections.abc","starlette._exception_handler","starlette.exceptions","starlette.requests","starlette.responses","starlette.types","starlette.websockets","__future__","typing","builtins","_frozen_importlib","abc"],"hash":"d8d5aedee9332fd9f09c3005645533c15ef87607","id":"starlette.middleware.exceptions","ignore_all":true,"interface_hash":"f12a047c45b871b93a735b9ce8e3e7eaf354da8b","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/starlette/middleware/exceptions.py","plugin_data":null,"size":2784,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/starlette/middleware/gzip.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/starlette/middleware/gzip.data.json new file mode 100644 index 0000000000000000000000000000000000000000..cba34ed586d8f6ba0db43a91072b526b9094c8ad --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/starlette/middleware/gzip.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"starlette.middleware.gzip","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","ASGIApp":{".class":"SymbolTableNode","cross_ref":"starlette.types.ASGIApp","kind":"Gdef"},"DEFAULT_EXCLUDED_CONTENT_TYPES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"starlette.middleware.gzip.DEFAULT_EXCLUDED_CONTENT_TYPES","name":"DEFAULT_EXCLUDED_CONTENT_TYPES","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"GZipMiddleware":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"starlette.middleware.gzip.GZipMiddleware","name":"GZipMiddleware","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"starlette.middleware.gzip.GZipMiddleware","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"starlette.middleware.gzip","mro":["starlette.middleware.gzip.GZipMiddleware","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","scope","receive","send"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"starlette.middleware.gzip.GZipMiddleware.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","scope","receive","send"],"arg_types":["starlette.middleware.gzip.GZipMiddleware",{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Scope"},{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Receive"},{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Send"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of GZipMiddleware","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","app","minimum_size","compresslevel"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"starlette.middleware.gzip.GZipMiddleware.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","app","minimum_size","compresslevel"],"arg_types":["starlette.middleware.gzip.GZipMiddleware",{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.ASGIApp"},"builtins.int","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of GZipMiddleware","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"app":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"starlette.middleware.gzip.GZipMiddleware.app","name":"app","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,null,null],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Scope"},{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Receive"},{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Send"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":[{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Awaitable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"compresslevel":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"starlette.middleware.gzip.GZipMiddleware.compresslevel","name":"compresslevel","setter_type":null,"type":"builtins.int"}},"minimum_size":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"starlette.middleware.gzip.GZipMiddleware.minimum_size","name":"minimum_size","setter_type":null,"type":"builtins.int"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"starlette.middleware.gzip.GZipMiddleware.Self","id":0,"name":"Self","namespace":"","upper_bound":"starlette.middleware.gzip.GZipMiddleware","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"GZipResponder":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["starlette.middleware.gzip.IdentityResponder"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"starlette.middleware.gzip.GZipResponder","name":"GZipResponder","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"starlette.middleware.gzip.GZipResponder","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"starlette.middleware.gzip","mro":["starlette.middleware.gzip.GZipResponder","starlette.middleware.gzip.IdentityResponder","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","scope","receive","send"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"starlette.middleware.gzip.GZipResponder.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","scope","receive","send"],"arg_types":["starlette.middleware.gzip.GZipResponder",{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Scope"},{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Receive"},{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Send"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of GZipResponder","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","app","minimum_size","compresslevel"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"starlette.middleware.gzip.GZipResponder.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","app","minimum_size","compresslevel"],"arg_types":["starlette.middleware.gzip.GZipResponder",{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.ASGIApp"},"builtins.int","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of GZipResponder","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"apply_compression":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,3],"arg_names":["self","body","more_body"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"starlette.middleware.gzip.GZipResponder.apply_compression","name":"apply_compression","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,3],"arg_names":["self","body","more_body"],"arg_types":["starlette.middleware.gzip.GZipResponder","builtins.bytes","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"apply_compression of GZipResponder","ret_type":"builtins.bytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"content_encoding":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"starlette.middleware.gzip.GZipResponder.content_encoding","name":"content_encoding","setter_type":null,"type":"builtins.str"}},"gzip_buffer":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"starlette.middleware.gzip.GZipResponder.gzip_buffer","name":"gzip_buffer","setter_type":null,"type":"_io.BytesIO"}},"gzip_file":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"starlette.middleware.gzip.GZipResponder.gzip_file","name":"gzip_file","setter_type":null,"type":"gzip.GzipFile"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"starlette.middleware.gzip.GZipResponder.Self","id":0,"name":"Self","namespace":"","upper_bound":"starlette.middleware.gzip.GZipResponder","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Headers":{".class":"SymbolTableNode","cross_ref":"starlette.datastructures.Headers","kind":"Gdef"},"IdentityResponder":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"starlette.middleware.gzip.IdentityResponder","name":"IdentityResponder","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"starlette.middleware.gzip.IdentityResponder","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"starlette.middleware.gzip","mro":["starlette.middleware.gzip.IdentityResponder","builtins.object"],"names":{".class":"SymbolTable","__call__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","scope","receive","send"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"starlette.middleware.gzip.IdentityResponder.__call__","name":"__call__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","scope","receive","send"],"arg_types":["starlette.middleware.gzip.IdentityResponder",{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Scope"},{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Receive"},{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Send"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__call__ of IdentityResponder","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","app","minimum_size"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"starlette.middleware.gzip.IdentityResponder.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","app","minimum_size"],"arg_types":["starlette.middleware.gzip.IdentityResponder",{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.ASGIApp"},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of IdentityResponder","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"app":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"starlette.middleware.gzip.IdentityResponder.app","name":"app","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":[null,null,null],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Scope"},{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Receive"},{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Send"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":[{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Awaitable"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"apply_compression":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,3],"arg_names":["self","body","more_body"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"starlette.middleware.gzip.IdentityResponder.apply_compression","name":"apply_compression","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,3],"arg_names":["self","body","more_body"],"arg_types":["starlette.middleware.gzip.IdentityResponder","builtins.bytes","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"apply_compression of IdentityResponder","ret_type":"builtins.bytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"content_encoding":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"starlette.middleware.gzip.IdentityResponder.content_encoding","name":"content_encoding","setter_type":null,"type":"builtins.str"}},"content_encoding_set":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"starlette.middleware.gzip.IdentityResponder.content_encoding_set","name":"content_encoding_set","setter_type":null,"type":"builtins.bool"}},"content_type_is_excluded":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"starlette.middleware.gzip.IdentityResponder.content_type_is_excluded","name":"content_type_is_excluded","setter_type":null,"type":"builtins.bool"}},"initial_message":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"starlette.middleware.gzip.IdentityResponder.initial_message","name":"initial_message","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Message"}}},"minimum_size":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"starlette.middleware.gzip.IdentityResponder.minimum_size","name":"minimum_size","setter_type":null,"type":"builtins.int"}},"send":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"starlette.middleware.gzip.IdentityResponder.send","name":"send","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Send"}}},"send_with_compression":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","message"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine","is_trivial_self"],"fullname":"starlette.middleware.gzip.IdentityResponder.send_with_compression","name":"send_with_compression","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","message"],"arg_types":["starlette.middleware.gzip.IdentityResponder",{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Message"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"send_with_compression of IdentityResponder","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"NoneType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"started":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"starlette.middleware.gzip.IdentityResponder.started","name":"started","setter_type":null,"type":"builtins.bool"}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"starlette.middleware.gzip.IdentityResponder.Self","id":0,"name":"Self","namespace":"","upper_bound":"starlette.middleware.gzip.IdentityResponder","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Message":{".class":"SymbolTableNode","cross_ref":"starlette.types.Message","kind":"Gdef"},"MutableHeaders":{".class":"SymbolTableNode","cross_ref":"starlette.datastructures.MutableHeaders","kind":"Gdef"},"NoReturn":{".class":"SymbolTableNode","cross_ref":"typing.NoReturn","kind":"Gdef"},"Receive":{".class":"SymbolTableNode","cross_ref":"starlette.types.Receive","kind":"Gdef"},"Scope":{".class":"SymbolTableNode","cross_ref":"starlette.types.Scope","kind":"Gdef"},"Send":{".class":"SymbolTableNode","cross_ref":"starlette.types.Send","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"starlette.middleware.gzip.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"starlette.middleware.gzip.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"starlette.middleware.gzip.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"starlette.middleware.gzip.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"starlette.middleware.gzip.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"starlette.middleware.gzip.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"gzip":{".class":"SymbolTableNode","cross_ref":"gzip","kind":"Gdef"},"io":{".class":"SymbolTableNode","cross_ref":"io","kind":"Gdef"},"unattached_send":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["message"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_coroutine"],"fullname":"starlette.middleware.gzip.unattached_send","name":"unattached_send","original_first_arg":"message","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["message"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"starlette.types.Message"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unattached_send","ret_type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6},{".class":"UninhabitedType"}],"extra_attrs":null,"type_ref":"typing.Coroutine"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/starlette/middleware/gzip.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/starlette/middleware/gzip.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/starlette/middleware/gzip.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..99392c403fd9668ffc88428520218fc01f5e5784 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/starlette/middleware/gzip.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106717,"dep_lines":[5,6,1,2,3,1,1,1,1,1,1,1],"dep_prios":[5,5,10,10,5,5,30,30,30,30,30,30],"dependencies":["starlette.datastructures","starlette.types","gzip","io","typing","builtins","_compression","_frozen_importlib","_io","abc","os","typing_extensions"],"hash":"3c6c881d17aefd7939d6ea2a1a0546d88382b702","id":"starlette.middleware.gzip","ignore_all":true,"interface_hash":"bd685e9d2bccecbbe72e5bbc932c59450f85677a","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/starlette/middleware/gzip.py","plugin_data":null,"size":5899,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/contrib/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/contrib/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..fb940f819910b10fa2dea156de469a3a05c7e633 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/contrib/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"urllib3.contrib","future_import_flags":[],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.contrib.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.contrib.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.contrib.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.contrib.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.contrib.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.contrib.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.contrib.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/urllib3/contrib/__init__.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/contrib/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/contrib/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..a2322693a72197fb495632f96b37856c1abf3c0d --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/contrib/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106713,"dep_lines":[1,1,1,1],"dep_prios":[5,30,30,30],"dependencies":["builtins","_frozen_importlib","abc","typing"],"hash":"da39a3ee5e6b4b0d3255bfef95601890afd80709","id":"urllib3.contrib","ignore_all":true,"interface_hash":"266642f9776d25a7302205ce88eb693187025fec","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/urllib3/contrib/__init__.py","plugin_data":null,"size":0,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/contrib/pyopenssl.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/contrib/pyopenssl.data.json new file mode 100644 index 0000000000000000000000000000000000000000..a02ff4370f4b43803f4c5238c6dc57018981bb76 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/contrib/pyopenssl.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"urllib3.contrib.pyopenssl","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","BytesIO":{".class":"SymbolTableNode","cross_ref":"_io.BytesIO","kind":"Gdef","module_public":false},"OpenSSL":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"urllib3.contrib.pyopenssl.OpenSSL","name":"OpenSSL","setter_type":null,"type":{".class":"AnyType","missing_import_name":"urllib3.contrib.pyopenssl.OpenSSL","source_any":null,"type_of_any":3}}},"PyOpenSSLContext":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext","name":"PyOpenSSLContext","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"urllib3.contrib.pyopenssl","mro":["urllib3.contrib.pyopenssl.PyOpenSSLContext","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","protocol"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","protocol"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of PyOpenSSLContext","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_ctx":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext._ctx","name":"_ctx","setter_type":null,"type":{".class":"AnyType","missing_import_name":"urllib3.contrib.pyopenssl.OpenSSL","source_any":{".class":"AnyType","missing_import_name":"urllib3.contrib.pyopenssl.OpenSSL","source_any":null,"type_of_any":3},"type_of_any":7}}},"_maximum_version":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext._maximum_version","name":"_maximum_version","setter_type":null,"type":"builtins.int"}},"_minimum_version":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext._minimum_version","name":"_minimum_version","setter_type":null,"type":"builtins.int"}},"_options":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext._options","name":"_options","setter_type":null,"type":"builtins.int"}},"_set_ctx_options":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext._set_ctx_options","name":"_set_ctx_options","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_set_ctx_options of PyOpenSSLContext","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_verify_flags":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext._verify_flags","name":"_verify_flags","setter_type":null,"type":"builtins.int"}},"check_hostname":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext.check_hostname","name":"check_hostname","setter_type":null,"type":"builtins.bool"}},"load_cert_chain":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","certfile","keyfile","password"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext.load_cert_chain","name":"load_cert_chain","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","certfile","keyfile","password"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext","builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"load_cert_chain of PyOpenSSLContext","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"load_verify_locations":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","cafile","capath","cadata"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext.load_verify_locations","name":"load_verify_locations","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","cafile","capath","cadata"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bytes",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"load_verify_locations of PyOpenSSLContext","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"maximum_version":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":["is_property"],"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext.maximum_version","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_overload","is_decorated","is_trivial_self"],"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext.maximum_version","name":"maximum_version","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"maximum_version of PyOpenSSLContext","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_settable_property","is_ready","is_inferred"],"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext.maximum_version","name":"maximum_version","setter_type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","maximum_version"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"maximum_version of PyOpenSSLContext","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"maximum_version of PyOpenSSLContext","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","maximum_version"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated","is_trivial_self"],"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext.maximum_version","name":"maximum_version","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","maximum_version"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"maximum_version of PyOpenSSLContext","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"","name":"maximum_version","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","maximum_version"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"maximum_version of PyOpenSSLContext","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":1,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"maximum_version of PyOpenSSLContext","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"minimum_version":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":["is_property"],"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext.minimum_version","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_overload","is_decorated","is_trivial_self"],"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext.minimum_version","name":"minimum_version","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"minimum_version of PyOpenSSLContext","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_settable_property","is_ready","is_inferred"],"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext.minimum_version","name":"minimum_version","setter_type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","minimum_version"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"minimum_version of PyOpenSSLContext","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"minimum_version of PyOpenSSLContext","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","minimum_version"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated","is_trivial_self"],"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext.minimum_version","name":"minimum_version","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","minimum_version"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"minimum_version of PyOpenSSLContext","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"","name":"minimum_version","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","minimum_version"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"minimum_version of PyOpenSSLContext","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":1,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"minimum_version of PyOpenSSLContext","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"options":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":["is_property"],"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext.options","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_overload","is_decorated","is_trivial_self"],"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext.options","name":"options","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"options of PyOpenSSLContext","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_settable_property","is_ready","is_inferred"],"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext.options","name":"options","setter_type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","value"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"options of PyOpenSSLContext","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"options of PyOpenSSLContext","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated","is_trivial_self"],"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext.options","name":"options","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","value"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"options of PyOpenSSLContext","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"","name":"options","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","value"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"options of PyOpenSSLContext","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":1,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"options of PyOpenSSLContext","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"protocol":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext.protocol","name":"protocol","setter_type":null,"type":"builtins.int"}},"set_alpn_protocols":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","protocols"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext.set_alpn_protocols","name":"set_alpn_protocols","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","protocols"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext",{".class":"Instance","args":[{".class":"UnionType","items":["builtins.bytes","builtins.str"],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.list"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"set_alpn_protocols of PyOpenSSLContext","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"set_ciphers":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","ciphers"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext.set_ciphers","name":"set_ciphers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","ciphers"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext",{".class":"UnionType","items":["builtins.bytes","builtins.str"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"set_ciphers of PyOpenSSLContext","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"set_default_verify_paths":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext.set_default_verify_paths","name":"set_default_verify_paths","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"set_default_verify_paths of PyOpenSSLContext","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"verify_flags":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":["is_property"],"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext.verify_flags","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_overload","is_decorated","is_trivial_self"],"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext.verify_flags","name":"verify_flags","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"verify_flags of PyOpenSSLContext","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_settable_property","is_ready","is_inferred"],"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext.verify_flags","name":"verify_flags","setter_type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","value"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"verify_flags of PyOpenSSLContext","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"verify_flags of PyOpenSSLContext","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated","is_trivial_self"],"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext.verify_flags","name":"verify_flags","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","value"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"verify_flags of PyOpenSSLContext","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"","name":"verify_flags","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","value"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"verify_flags of PyOpenSSLContext","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":1,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"verify_flags of PyOpenSSLContext","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"verify_mode":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":["is_property"],"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext.verify_mode","impl":null,"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_overload","is_decorated","is_trivial_self"],"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext.verify_mode","name":"verify_mode","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"verify_mode of PyOpenSSLContext","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_settable_property","is_ready","is_inferred"],"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext.verify_mode","name":"verify_mode","setter_type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","value"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext","ssl.VerifyMode"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"verify_mode of PyOpenSSLContext","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"verify_mode of PyOpenSSLContext","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_decorated","is_trivial_self"],"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext.verify_mode","name":"verify_mode","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","value"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext","ssl.VerifyMode"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"verify_mode of PyOpenSSLContext","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"","name":"verify_mode","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","value"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext","ssl.VerifyMode"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"verify_mode of PyOpenSSLContext","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":1,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"verify_mode of PyOpenSSLContext","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"wrap_socket":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1,1,1],"arg_names":["self","sock","server_side","do_handshake_on_connect","suppress_ragged_eofs","server_hostname"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext.wrap_socket","name":"wrap_socket","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1,1,1],"arg_names":["self","sock","server_side","do_handshake_on_connect","suppress_ragged_eofs","server_hostname"],"arg_types":["urllib3.contrib.pyopenssl.PyOpenSSLContext","socket.socket","builtins.bool","builtins.bool","builtins.bool",{".class":"UnionType","items":["builtins.bytes","builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"wrap_socket of PyOpenSSLContext","ret_type":"urllib3.contrib.pyopenssl.WrappedSocket","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.contrib.pyopenssl.PyOpenSSLContext.Self","id":0,"name":"Self","namespace":"","upper_bound":"urllib3.contrib.pyopenssl.PyOpenSSLContext","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"SSL_WRITE_BLOCKSIZE":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.contrib.pyopenssl.SSL_WRITE_BLOCKSIZE","name":"SSL_WRITE_BLOCKSIZE","setter_type":null,"type":"builtins.int"}},"UnsupportedExtension":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"urllib3.contrib.pyopenssl.UnsupportedExtension","name":"UnsupportedExtension","setter_type":null,"type":{".class":"AnyType","missing_import_name":"urllib3.contrib.pyopenssl.UnsupportedExtension","source_any":null,"type_of_any":3}}},"WrappedSocket":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"urllib3.contrib.pyopenssl.WrappedSocket","name":"WrappedSocket","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"urllib3.contrib.pyopenssl.WrappedSocket","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"urllib3.contrib.pyopenssl","mro":["urllib3.contrib.pyopenssl.WrappedSocket","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","connection","socket","suppress_ragged_eofs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.contrib.pyopenssl.WrappedSocket.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","connection","socket","suppress_ragged_eofs"],"arg_types":["urllib3.contrib.pyopenssl.WrappedSocket",{".class":"AnyType","missing_import_name":"urllib3.contrib.pyopenssl.OpenSSL","source_any":null,"type_of_any":3},"socket.socket","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of WrappedSocket","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_closed":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.contrib.pyopenssl.WrappedSocket._closed","name":"_closed","setter_type":null,"type":"builtins.bool"}},"_decref_socketios":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.contrib.pyopenssl.WrappedSocket._decref_socketios","name":"_decref_socketios","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.contrib.pyopenssl.WrappedSocket"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_decref_socketios of WrappedSocket","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_io_refs":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.contrib.pyopenssl.WrappedSocket._io_refs","name":"_io_refs","setter_type":null,"type":"builtins.int"}},"_real_close":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.contrib.pyopenssl.WrappedSocket._real_close","name":"_real_close","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.contrib.pyopenssl.WrappedSocket"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_real_close of WrappedSocket","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_send_until_done":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","data"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.contrib.pyopenssl.WrappedSocket._send_until_done","name":"_send_until_done","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","data"],"arg_types":["urllib3.contrib.pyopenssl.WrappedSocket","builtins.bytes"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_send_until_done of WrappedSocket","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"close":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.contrib.pyopenssl.WrappedSocket.close","name":"close","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.contrib.pyopenssl.WrappedSocket"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"close of WrappedSocket","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"connection":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.contrib.pyopenssl.WrappedSocket.connection","name":"connection","setter_type":null,"type":{".class":"AnyType","missing_import_name":"urllib3.contrib.pyopenssl.OpenSSL","source_any":null,"type_of_any":3}}},"fileno":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.contrib.pyopenssl.WrappedSocket.fileno","name":"fileno","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.contrib.pyopenssl.WrappedSocket"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fileno of WrappedSocket","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"getpeercert":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","binary_form"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.contrib.pyopenssl.WrappedSocket.getpeercert","name":"getpeercert","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","binary_form"],"arg_types":["urllib3.contrib.pyopenssl.WrappedSocket","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getpeercert of WrappedSocket","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str",{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"extra_attrs":null,"type_ref":"builtins.list"}],"extra_attrs":null,"type_ref":"builtins.dict"},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"recv":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.contrib.pyopenssl.WrappedSocket.recv","name":"recv","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"arg_types":["urllib3.contrib.pyopenssl.WrappedSocket",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"recv of WrappedSocket","ret_type":"builtins.bytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"recv_into":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.contrib.pyopenssl.WrappedSocket.recv_into","name":"recv_into","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2,4],"arg_names":["self","args","kwargs"],"arg_types":["urllib3.contrib.pyopenssl.WrappedSocket",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"recv_into of WrappedSocket","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"selected_alpn_protocol":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.contrib.pyopenssl.WrappedSocket.selected_alpn_protocol","name":"selected_alpn_protocol","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.contrib.pyopenssl.WrappedSocket"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"selected_alpn_protocol of WrappedSocket","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"sendall":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","data"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.contrib.pyopenssl.WrappedSocket.sendall","name":"sendall","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","data"],"arg_types":["urllib3.contrib.pyopenssl.WrappedSocket","builtins.bytes"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sendall of WrappedSocket","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"settimeout":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.contrib.pyopenssl.WrappedSocket.settimeout","name":"settimeout","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","timeout"],"arg_types":["urllib3.contrib.pyopenssl.WrappedSocket","builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"settimeout of WrappedSocket","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"shutdown":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","how"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.contrib.pyopenssl.WrappedSocket.shutdown","name":"shutdown","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","how"],"arg_types":["urllib3.contrib.pyopenssl.WrappedSocket","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shutdown of WrappedSocket","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"socket":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.contrib.pyopenssl.WrappedSocket.socket","name":"socket","setter_type":null,"type":"socket.socket"}},"suppress_ragged_eofs":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.contrib.pyopenssl.WrappedSocket.suppress_ragged_eofs","name":"suppress_ragged_eofs","setter_type":null,"type":"builtins.bool"}},"version":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.contrib.pyopenssl.WrappedSocket.version","name":"version","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.contrib.pyopenssl.WrappedSocket"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"version of WrappedSocket","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.contrib.pyopenssl.WrappedSocket.Self","id":0,"name":"Self","namespace":"","upper_bound":"urllib3.contrib.pyopenssl.WrappedSocket","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"X509":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"urllib3.contrib.pyopenssl.X509","name":"X509","setter_type":null,"type":{".class":"AnyType","missing_import_name":"urllib3.contrib.pyopenssl.X509","source_any":null,"type_of_any":3}}},"_OP_NO_SSLv2_OR_SSLv3":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"urllib3.contrib.pyopenssl._OP_NO_SSLv2_OR_SSLv3","name":"_OP_NO_SSLv2_OR_SSLv3","setter_type":null,"type":"builtins.int"}},"_OP_NO_TLSv1":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"urllib3.contrib.pyopenssl._OP_NO_TLSv1","name":"_OP_NO_TLSv1","setter_type":null,"type":"builtins.int"}},"_OP_NO_TLSv1_1":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"urllib3.contrib.pyopenssl._OP_NO_TLSv1_1","name":"_OP_NO_TLSv1_1","setter_type":null,"type":"builtins.int"}},"_OP_NO_TLSv1_2":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"urllib3.contrib.pyopenssl._OP_NO_TLSv1_2","name":"_OP_NO_TLSv1_2","setter_type":null,"type":"builtins.int"}},"_OP_NO_TLSv1_3":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"urllib3.contrib.pyopenssl._OP_NO_TLSv1_3","name":"_OP_NO_TLSv1_3","setter_type":null,"type":"builtins.int"}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.contrib.pyopenssl.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.contrib.pyopenssl.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.contrib.pyopenssl.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.contrib.pyopenssl.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.contrib.pyopenssl.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.contrib.pyopenssl.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.contrib.pyopenssl.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_dnsname_to_stdlib":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.contrib.pyopenssl._dnsname_to_stdlib","name":"_dnsname_to_stdlib","original_first_arg":"name","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["name"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_dnsname_to_stdlib","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_openssl_to_ssl_maximum_version":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"urllib3.contrib.pyopenssl._openssl_to_ssl_maximum_version","name":"_openssl_to_ssl_maximum_version","setter_type":null,"type":{".class":"Instance","args":["builtins.int","builtins.int"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_openssl_to_ssl_minimum_version":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"urllib3.contrib.pyopenssl._openssl_to_ssl_minimum_version","name":"_openssl_to_ssl_minimum_version","setter_type":null,"type":{".class":"Instance","args":["builtins.int","builtins.int"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_openssl_to_stdlib_verify":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.contrib.pyopenssl._openssl_to_stdlib_verify","name":"_openssl_to_stdlib_verify","setter_type":null,"type":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":"urllib3.contrib.pyopenssl.OpenSSL","source_any":{".class":"AnyType","missing_import_name":"urllib3.contrib.pyopenssl.OpenSSL","source_any":null,"type_of_any":3},"type_of_any":7},"ssl.VerifyMode"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_openssl_versions":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"urllib3.contrib.pyopenssl._openssl_versions","name":"_openssl_versions","setter_type":null,"type":{".class":"Instance","args":["builtins.int","builtins.int"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_stdlib_to_openssl_verify":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.contrib.pyopenssl._stdlib_to_openssl_verify","name":"_stdlib_to_openssl_verify","setter_type":null,"type":{".class":"Instance","args":["ssl.VerifyMode",{".class":"AnyType","missing_import_name":"urllib3.contrib.pyopenssl.OpenSSL","source_any":{".class":"AnyType","missing_import_name":"urllib3.contrib.pyopenssl.OpenSSL","source_any":null,"type_of_any":3},"type_of_any":7}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_validate_dependencies_met":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.contrib.pyopenssl._validate_dependencies_met","name":"_validate_dependencies_met","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_validate_dependencies_met","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_verify_callback":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0],"arg_names":["cnx","x509","err_no","err_depth","return_code"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.contrib.pyopenssl._verify_callback","name":"_verify_callback","original_first_arg":"cnx","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":["cnx","x509","err_no","err_depth","return_code"],"arg_types":[{".class":"AnyType","missing_import_name":"urllib3.contrib.pyopenssl.OpenSSL","source_any":null,"type_of_any":3},{".class":"AnyType","missing_import_name":"urllib3.contrib.pyopenssl.X509","source_any":null,"type_of_any":3},"builtins.int","builtins.int","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_verify_callback","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef","module_public":false},"extract_from_urllib3":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.contrib.pyopenssl.extract_from_urllib3","name":"extract_from_urllib3","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"extract_from_urllib3","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_subj_alt_name":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["peer_cert"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.contrib.pyopenssl.get_subj_alt_name","name":"get_subj_alt_name","original_first_arg":"peer_cert","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["peer_cert"],"arg_types":[{".class":"AnyType","missing_import_name":"urllib3.contrib.pyopenssl.X509","source_any":null,"type_of_any":3}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_subj_alt_name","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"builtins.list"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"inject_into_urllib3":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.contrib.pyopenssl.inject_into_urllib3","name":"inject_into_urllib3","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"inject_into_urllib3","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"log":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.contrib.pyopenssl.log","name":"log","setter_type":null,"type":"logging.Logger"}},"logging":{".class":"SymbolTableNode","cross_ref":"logging","kind":"Gdef","module_public":false},"orig_util_SSLContext":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.contrib.pyopenssl.orig_util_SSLContext","name":"orig_util_SSLContext","setter_type":null,"type":{".class":"NoneType"}}},"socket_cls":{".class":"SymbolTableNode","cross_ref":"socket.socket","kind":"Gdef","module_public":false},"ssl":{".class":"SymbolTableNode","cross_ref":"ssl","kind":"Gdef","module_public":false},"timeout":{".class":"SymbolTableNode","cross_ref":"socket.timeout","kind":"Gdef","module_public":false},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef","module_public":false},"util":{".class":"SymbolTableNode","cross_ref":"urllib3.util","kind":"Gdef","module_public":false},"x509":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"urllib3.contrib.pyopenssl.x509","name":"x509","setter_type":null,"type":{".class":"AnyType","missing_import_name":"urllib3.contrib.pyopenssl.x509","source_any":null,"type_of_any":3}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/urllib3/contrib/pyopenssl.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/contrib/pyopenssl.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/contrib/pyopenssl.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..0c00097eaa870b5fb51278fc22de7add4303004c --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/contrib/pyopenssl.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106716,"dep_lines":[61,41,54,55,56,57,58,61,1,1,1,1,1,1,1,1,1,43,47,64,43,44],"dep_prios":[10,5,10,10,10,5,5,20,5,30,30,30,30,30,30,30,30,10,5,25,20,5],"dependencies":["urllib3.util","__future__","logging","ssl","typing","io","socket","urllib3","builtins","_collections_abc","_frozen_importlib","_io","_socket","abc","enum","types","urllib3.util.ssl_"],"hash":"3edde8399d4e4e5ababa38ccb9addcea87554764","id":"urllib3.contrib.pyopenssl","ignore_all":true,"interface_hash":"cc16e9c25b56413d7b3d41625777924657aeb152","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/urllib3/contrib/pyopenssl.py","plugin_data":null,"size":19720,"suppressed":["OpenSSL.SSL","cryptography.x509","OpenSSL.crypto","OpenSSL","cryptography"],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/http2/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/http2/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..4f55b5e54679cfaef07c75ffc4971b12c4805f42 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/http2/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"urllib3.http2","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.http2.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.http2.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.http2.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.http2.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.http2.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.http2.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.http2.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.http2.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef","module_public":false},"extract_from_urllib3":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.http2.extract_from_urllib3","name":"extract_from_urllib3","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"extract_from_urllib3","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"inject_into_urllib3":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.http2.inject_into_urllib3","name":"inject_into_urllib3","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"inject_into_urllib3","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"orig_HTTPSConnection":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"urllib3.http2.orig_HTTPSConnection","name":"orig_HTTPSConnection","setter_type":null,"type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}}},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef","module_public":false},"version":{".class":"SymbolTableNode","cross_ref":"importlib.metadata.version","kind":"Gdef","module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/urllib3/http2/__init__.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/http2/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/http2/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..c32df42dfba7df71220fcdb3cfc98d6ef379e657 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/http2/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106714,"dep_lines":[3,1,10,1,1,1],"dep_prios":[5,5,10,5,30,30],"dependencies":["importlib.metadata","__future__","typing","builtins","_frozen_importlib","abc"],"hash":"3e0de2068e4b0cdff235a49d6acda3db24d4aec2","id":"urllib3.http2","ignore_all":true,"interface_hash":"4a33ad05683194b1619dfbfefffc779e76303bf8","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/urllib3/http2/__init__.py","plugin_data":null,"size":1741,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/http2/probe.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/http2/probe.data.json new file mode 100644 index 0000000000000000000000000000000000000000..edb655c99356f5d1f42ae14b48cb8377310778ee --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/http2/probe.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"urllib3.http2.probe","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","_HTTP2ProbeCache":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"urllib3.http2.probe._HTTP2ProbeCache","name":"_HTTP2ProbeCache","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"urllib3.http2.probe._HTTP2ProbeCache","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"urllib3.http2.probe","mro":["urllib3.http2.probe._HTTP2ProbeCache","builtins.object"],"names":{".class":"SymbolTable","__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.http2.probe._HTTP2ProbeCache.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.http2.probe._HTTP2ProbeCache"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of _HTTP2ProbeCache","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__slots__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value","allow_incompatible_override"],"fullname":"urllib3.http2.probe._HTTP2ProbeCache.__slots__","name":"__slots__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_cache_locks":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"urllib3.http2.probe._HTTP2ProbeCache._cache_locks","name":"_cache_locks","setter_type":null,"type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"_thread.RLock"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_cache_values":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"urllib3.http2.probe._HTTP2ProbeCache._cache_values","name":"_cache_values","setter_type":null,"type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_lock":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.http2.probe._HTTP2ProbeCache._lock","name":"_lock","setter_type":null,"type":"_thread.LockType"}},"_reset":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.http2.probe._HTTP2ProbeCache._reset","name":"_reset","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.http2.probe._HTTP2ProbeCache"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_reset of _HTTP2ProbeCache","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_values":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.http2.probe._HTTP2ProbeCache._values","name":"_values","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.http2.probe._HTTP2ProbeCache"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_values of _HTTP2ProbeCache","ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"acquire_and_get":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","host","port"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.http2.probe._HTTP2ProbeCache.acquire_and_get","name":"acquire_and_get","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","host","port"],"arg_types":["urllib3.http2.probe._HTTP2ProbeCache","builtins.str","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"acquire_and_get of _HTTP2ProbeCache","ret_type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"set_and_release":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","host","port","supports_http2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.http2.probe._HTTP2ProbeCache.set_and_release","name":"set_and_release","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","host","port","supports_http2"],"arg_types":["urllib3.http2.probe._HTTP2ProbeCache","builtins.str","builtins.int",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"set_and_release of _HTTP2ProbeCache","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.http2.probe._HTTP2ProbeCache.Self","id":0,"name":"Self","namespace":"","upper_bound":"urllib3.http2.probe._HTTP2ProbeCache","values":[],"variance":0},"slots":["_cache_locks","_cache_values","_lock"],"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_HTTP2_PROBE_CACHE":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.http2.probe._HTTP2_PROBE_CACHE","name":"_HTTP2_PROBE_CACHE","setter_type":null,"type":"urllib3.http2.probe._HTTP2ProbeCache"}},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.http2.probe.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.http2.probe.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.http2.probe.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.http2.probe.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.http2.probe.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.http2.probe.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.http2.probe.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_reset":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.http2.probe._reset","name":"_reset","setter_type":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_values":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.http2.probe._values","name":"_values","setter_type":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"acquire_and_get":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.http2.probe.acquire_and_get","name":"acquire_and_get","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["host","port"],"arg_types":["builtins.str","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef","module_public":false},"set_and_release":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.http2.probe.set_and_release","name":"set_and_release","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["host","port","supports_http2"],"arg_types":["builtins.str","builtins.int",{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":true,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"threading":{".class":"SymbolTableNode","cross_ref":"threading","kind":"Gdef","module_public":false}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/urllib3/http2/probe.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/http2/probe.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/http2/probe.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..c9aa9b3fade14d7155dabdc43a3e3430ec8d25c9 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/http2/probe.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106714,"dep_lines":[1,3,1,1,1,1,1],"dep_prios":[5,10,5,30,30,30,30],"dependencies":["__future__","threading","builtins","_frozen_importlib","_thread","abc","typing"],"hash":"0f3acba2ec85a7130d05f77c099dd9440c817e84","id":"urllib3.http2.probe","ignore_all":true,"interface_hash":"aa5d3caf0f861faf7889a8676cc33f09ba36c84e","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/urllib3/http2/probe.py","plugin_data":null,"size":3014,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/__init__.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/__init__.data.json new file mode 100644 index 0000000000000000000000000000000000000000..8c9fad800854f2b6bf325a4664fd9c28f350620a --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/__init__.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"urllib3.util","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","ALPN_PROTOCOLS":{".class":"SymbolTableNode","cross_ref":"urllib3.util.ssl_.ALPN_PROTOCOLS","kind":"Gdef"},"IS_PYOPENSSL":{".class":"SymbolTableNode","cross_ref":"urllib3.util.ssl_.IS_PYOPENSSL","kind":"Gdef"},"Retry":{".class":"SymbolTableNode","cross_ref":"urllib3.util.retry.Retry","kind":"Gdef"},"SKIPPABLE_HEADERS":{".class":"SymbolTableNode","cross_ref":"urllib3.util.request.SKIPPABLE_HEADERS","kind":"Gdef"},"SKIP_HEADER":{".class":"SymbolTableNode","cross_ref":"urllib3.util.request.SKIP_HEADER","kind":"Gdef"},"SSLContext":{".class":"SymbolTableNode","cross_ref":"urllib3.util.ssl_.SSLContext","kind":"Gdef"},"Timeout":{".class":"SymbolTableNode","cross_ref":"urllib3.util.timeout.Timeout","kind":"Gdef"},"Url":{".class":"SymbolTableNode","cross_ref":"urllib3.util.url.Url","kind":"Gdef"},"__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.__all__","name":"__all__","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__path__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.__path__","name":"__path__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef","module_public":false},"assert_fingerprint":{".class":"SymbolTableNode","cross_ref":"urllib3.util.ssl_.assert_fingerprint","kind":"Gdef"},"create_urllib3_context":{".class":"SymbolTableNode","cross_ref":"urllib3.util.ssl_.create_urllib3_context","kind":"Gdef"},"is_connection_dropped":{".class":"SymbolTableNode","cross_ref":"urllib3.util.connection.is_connection_dropped","kind":"Gdef"},"is_fp_closed":{".class":"SymbolTableNode","cross_ref":"urllib3.util.response.is_fp_closed","kind":"Gdef"},"make_headers":{".class":"SymbolTableNode","cross_ref":"urllib3.util.request.make_headers","kind":"Gdef"},"parse_url":{".class":"SymbolTableNode","cross_ref":"urllib3.util.url.parse_url","kind":"Gdef"},"resolve_cert_reqs":{".class":"SymbolTableNode","cross_ref":"urllib3.util.ssl_.resolve_cert_reqs","kind":"Gdef"},"resolve_ssl_version":{".class":"SymbolTableNode","cross_ref":"urllib3.util.ssl_.resolve_ssl_version","kind":"Gdef"},"ssl_wrap_socket":{".class":"SymbolTableNode","cross_ref":"urllib3.util.ssl_.ssl_wrap_socket","kind":"Gdef"},"wait_for_read":{".class":"SymbolTableNode","cross_ref":"urllib3.util.wait.wait_for_read","kind":"Gdef"},"wait_for_write":{".class":"SymbolTableNode","cross_ref":"urllib3.util.wait.wait_for_write","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/urllib3/util/__init__.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/__init__.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/__init__.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..d2f8bcf6c6b6b9c56126b2100c3ed628873762dc --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/__init__.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[4,5,6,7,8,18,19,20,2,1,1,1,1],"dep_prios":[5,5,5,5,5,5,5,5,5,5,30,30,30],"dependencies":["urllib3.util.connection","urllib3.util.request","urllib3.util.response","urllib3.util.retry","urllib3.util.ssl_","urllib3.util.timeout","urllib3.util.url","urllib3.util.wait","__future__","builtins","_frozen_importlib","abc","typing"],"hash":"52460d96b307e3cb7da56a187fc2c4e597de3c87","id":"urllib3.util","ignore_all":true,"interface_hash":"2b390adf91726fa8bf8371dc08f869577d740b34","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/urllib3/util/__init__.py","plugin_data":null,"size":1001,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/connection.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/connection.data.json new file mode 100644 index 0000000000000000000000000000000000000000..eb75c3591dcafc278e7ab83392577d6bc718dd95 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/connection.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"urllib3.util.connection","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","BaseHTTPConnection":{".class":"SymbolTableNode","cross_ref":"urllib3._base_connection.BaseHTTPConnection","kind":"Gdef"},"HAS_IPV6":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.connection.HAS_IPV6","name":"HAS_IPV6","setter_type":null,"type":"builtins.bool"}},"LocationParseError":{".class":"SymbolTableNode","cross_ref":"urllib3.exceptions.LocationParseError","kind":"Gdef"},"_DEFAULT_TIMEOUT":{".class":"SymbolTableNode","cross_ref":"urllib3.util.timeout._DEFAULT_TIMEOUT","kind":"Gdef"},"_TYPE_SOCKET_OPTIONS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"urllib3.util.connection._TYPE_SOCKET_OPTIONS","line":9,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int",{".class":"UnionType","items":["builtins.int","builtins.bytes"],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"builtins.list"}}},"_TYPE_TIMEOUT":{".class":"SymbolTableNode","cross_ref":"urllib3.util.timeout._TYPE_TIMEOUT","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.connection.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.connection.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.connection.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.connection.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.connection.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.connection.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_has_ipv6":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["host"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.connection._has_ipv6","name":"_has_ipv6","original_first_arg":"host","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["host"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_has_ipv6","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_set_socket_options":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["sock","options"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.connection._set_socket_options","name":"_set_socket_options","original_first_arg":"sock","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["sock","options"],"arg_types":["socket.socket",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"urllib3.util.connection._TYPE_SOCKET_OPTIONS"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_set_socket_options","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"allowed_gai_family":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.connection.allowed_gai_family","name":"allowed_gai_family","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"allowed_gai_family","ret_type":"socket.AddressFamily","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"create_connection":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["address","timeout","source_address","socket_options"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.connection.create_connection","name":"create_connection","original_first_arg":"address","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["address","timeout","source_address","socket_options"],"arg_types":[{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"TypeAliasType","args":[],"type_ref":"urllib3.util.timeout._TYPE_TIMEOUT"},{".class":"UnionType","items":[{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"urllib3.util.connection._TYPE_SOCKET_OPTIONS"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"create_connection","ret_type":"socket.socket","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_connection_dropped":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["conn"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.connection.is_connection_dropped","name":"is_connection_dropped","original_first_arg":"conn","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["conn"],"arg_types":["urllib3._base_connection.BaseHTTPConnection"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_connection_dropped","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"socket":{".class":"SymbolTableNode","cross_ref":"socket","kind":"Gdef"},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/urllib3/util/connection.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/connection.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/connection.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..ca8457ce7b1fdd93b37b589f63fb7e4dd28f9c5d --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/connection.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[7,6,12,1,3,4,1,1,1,1,1],"dep_prios":[5,5,25,5,10,10,5,30,30,30,30],"dependencies":["urllib3.util.timeout","urllib3.exceptions","urllib3._base_connection","__future__","socket","typing","builtins","_frozen_importlib","_socket","abc","enum"],"hash":"f4235cec4a7e67717e649a33df5a2f4f6abfbbb9","id":"urllib3.util.connection","ignore_all":true,"interface_hash":"f644156bab44deadf8618add1702aa4294923d8d","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/urllib3/util/connection.py","plugin_data":null,"size":4444,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/proxy.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/proxy.data.json new file mode 100644 index 0000000000000000000000000000000000000000..c9a2227ff5b64e326eb7025d576c4c56f31b8983 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/proxy.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"urllib3.util.proxy","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","ProxyConfig":{".class":"SymbolTableNode","cross_ref":"urllib3._base_connection.ProxyConfig","kind":"Gdef"},"Url":{".class":"SymbolTableNode","cross_ref":"urllib3.util.url.Url","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.proxy.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.proxy.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.proxy.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.proxy.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.proxy.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.proxy.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"connection_requires_http_tunnel":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1,1,1],"arg_names":["proxy_url","proxy_config","destination_scheme"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.proxy.connection_requires_http_tunnel","name":"connection_requires_http_tunnel","original_first_arg":"proxy_url","type":{".class":"CallableType","arg_kinds":[1,1,1],"arg_names":["proxy_url","proxy_config","destination_scheme"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"urllib3.util.url.Url"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"urllib3._base_connection.ProxyConfig"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"connection_requires_http_tunnel","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/urllib3/util/proxy.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/proxy.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/proxy.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..ab87fd9d1799ea674c24734e8bd23fa0b68ae73f --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/proxy.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[5,8,1,3,1,1,1,1,1,1],"dep_prios":[5,25,5,10,5,30,30,30,30,30],"dependencies":["urllib3.util.url","urllib3.connection","__future__","typing","builtins","_frozen_importlib","_ssl","abc","ssl","urllib3._base_connection"],"hash":"a10a3a580a9fef94af52cf37e00a9913e0f64da0","id":"urllib3.util.proxy","ignore_all":true,"interface_hash":"33588c2285e356db90ccbdf9648ef2354d87e34a","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/urllib3/util/proxy.py","plugin_data":null,"size":1148,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/request.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/request.data.json new file mode 100644 index 0000000000000000000000000000000000000000..29bb900a4161edaedefa79d742989723ae1b07a5 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/request.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"urllib3.util.request","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","ACCEPT_ENCODING":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.request.ACCEPT_ENCODING","name":"ACCEPT_ENCODING","setter_type":null,"type":"builtins.str"}},"ChunksAndContentLength":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"},"builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"urllib3.util.request.ChunksAndContentLength","name":"ChunksAndContentLength","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_named_tuple"],"fullname":"urllib3.util.request.ChunksAndContentLength","has_param_spec_type":false,"metaclass_type":null,"metadata":{"namedtuple":{"fields":["chunks","content_length"]}},"module_name":"urllib3.util.request","mro":["urllib3.util.request.ChunksAndContentLength","builtins.tuple","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","_NT":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.request.ChunksAndContentLength._NT","name":"_NT","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"},"builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},"__annotations__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"urllib3.util.request.ChunksAndContentLength.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"urllib3.util.request.ChunksAndContentLength.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__new__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["_cls","chunks","content_length"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static"],"fullname":"urllib3.util.request.ChunksAndContentLength.__new__","name":"__new__","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["_cls","chunks","content_length"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.request.ChunksAndContentLength._NT","id":-1,"name":"_NT","namespace":"urllib3.util.request.ChunksAndContentLength.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"},"builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of ChunksAndContentLength","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.request.ChunksAndContentLength._NT","id":-1,"name":"_NT","namespace":"urllib3.util.request.ChunksAndContentLength.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"},"builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.request.ChunksAndContentLength._NT","id":-1,"name":"_NT","namespace":"urllib3.util.request.ChunksAndContentLength.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"},"builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_asdict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["_self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.request.ChunksAndContentLength._asdict","name":"_asdict","original_first_arg":"_self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["_self"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.request.ChunksAndContentLength._NT","id":-1,"name":"_NT","namespace":"urllib3.util.request.ChunksAndContentLength._asdict","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"},"builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_asdict of ChunksAndContentLength","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.request.ChunksAndContentLength._NT","id":-1,"name":"_NT","namespace":"urllib3.util.request.ChunksAndContentLength._asdict","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"},"builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_field_defaults":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"urllib3.util.request.ChunksAndContentLength._field_defaults","name":"_field_defaults","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_field_types":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"urllib3.util.request.ChunksAndContentLength._field_types","name":"_field_types","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_fields":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"urllib3.util.request.ChunksAndContentLength._fields","name":"_fields","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_make":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["_cls","iterable"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated"],"fullname":"urllib3.util.request.ChunksAndContentLength._make","name":"_make","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["_cls","iterable"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.request.ChunksAndContentLength._NT","id":-1,"name":"_NT","namespace":"urllib3.util.request.ChunksAndContentLength._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"},"builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_make of ChunksAndContentLength","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.request.ChunksAndContentLength._NT","id":-1,"name":"_NT","namespace":"urllib3.util.request.ChunksAndContentLength._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"},"builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.request.ChunksAndContentLength._NT","id":-1,"name":"_NT","namespace":"urllib3.util.request.ChunksAndContentLength._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"},"builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_classmethod","is_ready"],"fullname":"urllib3.util.request.ChunksAndContentLength._make","name":"_make","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["_cls","iterable"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.request.ChunksAndContentLength._NT","id":-1,"name":"_NT","namespace":"urllib3.util.request.ChunksAndContentLength._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"},"builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_make of ChunksAndContentLength","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.request.ChunksAndContentLength._NT","id":-1,"name":"_NT","namespace":"urllib3.util.request.ChunksAndContentLength._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"},"builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.request.ChunksAndContentLength._NT","id":-1,"name":"_NT","namespace":"urllib3.util.request.ChunksAndContentLength._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"},"builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}}},"plugin_generated":true},"_replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5],"arg_names":["_self","chunks","content_length"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.request.ChunksAndContentLength._replace","name":"_replace","original_first_arg":"_self","type":{".class":"CallableType","arg_kinds":[0,5,5],"arg_names":["_self","chunks","content_length"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.request.ChunksAndContentLength._NT","id":-1,"name":"_NT","namespace":"urllib3.util.request.ChunksAndContentLength._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"},"builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_replace of ChunksAndContentLength","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.request.ChunksAndContentLength._NT","id":-1,"name":"_NT","namespace":"urllib3.util.request.ChunksAndContentLength._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"},"builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.request.ChunksAndContentLength._NT","id":-1,"name":"_NT","namespace":"urllib3.util.request.ChunksAndContentLength._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"},"builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_source":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"urllib3.util.request.ChunksAndContentLength._source","name":"_source","setter_type":null,"type":"builtins.str"}},"chunks":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"urllib3.util.request.ChunksAndContentLength.chunks","name":"chunks","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true}}},"chunks-redefinition":{".class":"SymbolTableNode","cross_ref":"urllib3.util.request.ChunksAndContentLength.chunks","kind":"Mdef"},"content_length":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"urllib3.util.request.ChunksAndContentLength.content_length","name":"content_length","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"content_length-redefinition":{".class":"SymbolTableNode","cross_ref":"urllib3.util.request.ChunksAndContentLength.content_length","kind":"Mdef"}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.request.ChunksAndContentLength.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":"urllib3.util.request.ChunksAndContentLength"},"values":[],"variance":0},"slots":null,"tuple_type":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":[{".class":"Instance","args":["builtins.bytes"],"extra_attrs":null,"type_ref":"typing.Iterable"},{".class":"NoneType"},"builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_vars":[],"typeddict_type":null}},"Enum":{".class":"SymbolTableNode","cross_ref":"enum.Enum","kind":"Gdef"},"Final":{".class":"SymbolTableNode","cross_ref":"typing.Final","kind":"Gdef"},"SKIPPABLE_HEADERS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.request.SKIPPABLE_HEADERS","name":"SKIPPABLE_HEADERS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.frozenset"}}},"SKIP_HEADER":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.request.SKIP_HEADER","name":"SKIP_HEADER","setter_type":null,"type":"builtins.str"}},"UnrewindableBodyError":{".class":"SymbolTableNode","cross_ref":"urllib3.exceptions.UnrewindableBodyError","kind":"Gdef"},"_FAILEDTELL":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"urllib3.util.request._FAILEDTELL","name":"_FAILEDTELL","setter_type":null,"type":"urllib3.util.request._TYPE_FAILEDTELL"}},"_METHODS_NOT_EXPECTING_BODY":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.request._METHODS_NOT_EXPECTING_BODY","name":"_METHODS_NOT_EXPECTING_BODY","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"_TYPE_BODY_POSITION":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"urllib3.util.request._TYPE_BODY_POSITION","line":53,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["builtins.int","urllib3.util.request._TYPE_FAILEDTELL"],"uses_pep604_syntax":false}}},"_TYPE_FAILEDTELL":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["enum.Enum"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"urllib3.util.request._TYPE_FAILEDTELL","name":"_TYPE_FAILEDTELL","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_enum"],"fullname":"urllib3.util.request._TYPE_FAILEDTELL","has_param_spec_type":false,"metaclass_type":"enum.EnumMeta","metadata":{},"module_name":"urllib3.util.request","mro":["urllib3.util.request._TYPE_FAILEDTELL","enum.Enum","builtins.object"],"names":{".class":"SymbolTable","token":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.request._TYPE_FAILEDTELL.token","name":"token","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.int","value":0},"type_ref":"builtins.int"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.request._TYPE_FAILEDTELL.Self","id":0,"name":"Self","namespace":"","upper_bound":"urllib3.util.request._TYPE_FAILEDTELL","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.request.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.request.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.request.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.request.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.request.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.request.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_unused_module_brotli":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"urllib3.util.request._unused_module_brotli","name":"_unused_module_brotli","setter_type":null,"type":{".class":"AnyType","missing_import_name":"urllib3.util.request._unused_module_brotli","source_any":null,"type_of_any":3}}},"_unused_module_zstd":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_suppressed_import","is_ready","is_inferred"],"fullname":"urllib3.util.request._unused_module_zstd","name":"_unused_module_zstd","setter_type":null,"type":{".class":"AnyType","missing_import_name":"urllib3.util.request._unused_module_zstd","source_any":null,"type_of_any":3}}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"b64encode":{".class":"SymbolTableNode","cross_ref":"base64.b64encode","kind":"Gdef"},"body_to_chunks":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["body","method","blocksize"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.request.body_to_chunks","name":"body_to_chunks","original_first_arg":"body","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["body","method","blocksize"],"arg_types":[{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"body_to_chunks","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"urllib3.util.request.ChunksAndContentLength"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"io":{".class":"SymbolTableNode","cross_ref":"io","kind":"Gdef"},"make_headers":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1,1,1,1,1,1],"arg_names":["keep_alive","accept_encoding","user_agent","basic_auth","proxy_basic_auth","disable_cache"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.request.make_headers","name":"make_headers","original_first_arg":"keep_alive","type":{".class":"CallableType","arg_kinds":[1,1,1,1,1,1],"arg_names":["keep_alive","accept_encoding","user_agent","basic_auth","proxy_basic_auth","disable_cache"],"arg_types":[{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"},"builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"make_headers","ret_type":{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"rewind_body":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["body","body_pos"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.request.rewind_body","name":"rewind_body","original_first_arg":"body","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["body","body_pos"],"arg_types":[{".class":"Instance","args":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"typing.AnyStr","namespace":"urllib3.util.request.rewind_body","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}],"extra_attrs":null,"type_ref":"typing.IO"},{".class":"TypeAliasType","args":[],"type_ref":"urllib3.util.request._TYPE_BODY_POSITION"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"rewind_body","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"typing.AnyStr","id":-1,"name":"typing.AnyStr","namespace":"urllib3.util.request.rewind_body","upper_bound":"builtins.object","values":["builtins.str","builtins.bytes"],"variance":0}]}}},"set_file_position":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["body","pos"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.request.set_file_position","name":"set_file_position","original_first_arg":"body","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["body","pos"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"urllib3.util.request._TYPE_BODY_POSITION"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"set_file_position","ret_type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"urllib3.util.request._TYPE_BODY_POSITION"},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"to_bytes":{".class":"SymbolTableNode","cross_ref":"urllib3.util.util.to_bytes","kind":"Gdef"},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/urllib3/util/request.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/request.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/request.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..f4e90f74518eb29e525542717de6385f7268003e --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/request.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[9,8,1,3,4,5,6,1,1,1,26,24,40,33],"dep_prios":[5,5,5,10,10,5,5,5,30,30,10,10,10,5],"dependencies":["urllib3.util.util","urllib3.exceptions","__future__","io","typing","base64","enum","builtins","_frozen_importlib","abc"],"hash":"66ff35e563f97ed15a4380a0f27104169fb9eb51","id":"urllib3.util.request","ignore_all":true,"interface_hash":"c941b0ed2cc4d9952f8cad19ef81081fbb8171c1","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/urllib3/util/request.py","plugin_data":null,"size":8411,"suppressed":["brotli","brotlicffi","zstandard","compression"],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/response.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/response.data.json new file mode 100644 index 0000000000000000000000000000000000000000..83c74e342f4a33ec77c6a809892fdc32a310c622 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/response.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"urllib3.util.response","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","HeaderParsingError":{".class":"SymbolTableNode","cross_ref":"urllib3.exceptions.HeaderParsingError","kind":"Gdef"},"MultipartInvariantViolationDefect":{".class":"SymbolTableNode","cross_ref":"email.errors.MultipartInvariantViolationDefect","kind":"Gdef"},"StartBoundaryNotFoundDefect":{".class":"SymbolTableNode","cross_ref":"email.errors.StartBoundaryNotFoundDefect","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.response.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.response.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.response.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.response.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.response.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.response.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"assert_header_parsing":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["headers"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.response.assert_header_parsing","name":"assert_header_parsing","original_first_arg":"headers","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["headers"],"arg_types":["http.client.HTTPMessage"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_header_parsing","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"httplib":{".class":"SymbolTableNode","cross_ref":"http.client","kind":"Gdef"},"is_fp_closed":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["obj"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.response.is_fp_closed","name":"is_fp_closed","original_first_arg":"obj","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["obj"],"arg_types":["builtins.object"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_fp_closed","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_response_to_head":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["response"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.response.is_response_to_head","name":"is_response_to_head","original_first_arg":"response","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["response"],"arg_types":["http.client.HTTPResponse"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_response_to_head","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/urllib3/util/response.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/response.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/response.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..21dcbccadd65eb07e223d2483224339c2a5529f8 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/response.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[3,4,6,1,3,1,1,1,1,1,1,1,1],"dep_prios":[10,5,5,5,20,5,30,30,30,30,30,30,30],"dependencies":["http.client","email.errors","urllib3.exceptions","__future__","http","builtins","_frozen_importlib","_io","abc","email","email.message","io","typing"],"hash":"f296cb85d9df58e5f40f560c9dae60db5af70961","id":"urllib3.util.response","ignore_all":true,"interface_hash":"6a50d211904d332eb0f116d06daaf1896afedaa9","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/urllib3/util/response.py","plugin_data":null,"size":3374,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/retry.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/retry.data.json new file mode 100644 index 0000000000000000000000000000000000000000..04b984e6f4abca40f874391461165540cad403e5 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/retry.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"urllib3.util.retry","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","BaseHTTPResponse":{".class":"SymbolTableNode","cross_ref":"urllib3.response.BaseHTTPResponse","kind":"Gdef"},"ConnectTimeoutError":{".class":"SymbolTableNode","cross_ref":"urllib3.exceptions.ConnectTimeoutError","kind":"Gdef"},"ConnectionPool":{".class":"SymbolTableNode","cross_ref":"urllib3.connectionpool.ConnectionPool","kind":"Gdef"},"InvalidHeader":{".class":"SymbolTableNode","cross_ref":"urllib3.exceptions.InvalidHeader","kind":"Gdef"},"MaxRetryError":{".class":"SymbolTableNode","cross_ref":"urllib3.exceptions.MaxRetryError","kind":"Gdef"},"ProtocolError":{".class":"SymbolTableNode","cross_ref":"urllib3.exceptions.ProtocolError","kind":"Gdef"},"ProxyError":{".class":"SymbolTableNode","cross_ref":"urllib3.exceptions.ProxyError","kind":"Gdef"},"ReadTimeoutError":{".class":"SymbolTableNode","cross_ref":"urllib3.exceptions.ReadTimeoutError","kind":"Gdef"},"RequestHistory":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"},"builtins.Exception","builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"urllib3.util.retry.RequestHistory","name":"RequestHistory","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_named_tuple"],"fullname":"urllib3.util.retry.RequestHistory","has_param_spec_type":false,"metaclass_type":null,"metadata":{"namedtuple":{"fields":["method","url","error","status","redirect_location"]}},"module_name":"urllib3.util.retry","mro":["urllib3.util.retry.RequestHistory","builtins.tuple","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","_NT":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.retry.RequestHistory._NT","name":"_NT","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.Exception",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"},"builtins.Exception","builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},"__annotations__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"urllib3.util.retry.RequestHistory.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"urllib3.util.retry.RequestHistory.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__new__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0,0],"arg_names":["_cls","method","url","error","status","redirect_location"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static"],"fullname":"urllib3.util.retry.RequestHistory.__new__","name":"__new__","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0],"arg_names":["_cls","method","url","error","status","redirect_location"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.retry.RequestHistory._NT","id":-1,"name":"_NT","namespace":"urllib3.util.retry.RequestHistory.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.Exception",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"},"builtins.Exception","builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.Exception",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of RequestHistory","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.retry.RequestHistory._NT","id":-1,"name":"_NT","namespace":"urllib3.util.retry.RequestHistory.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.Exception",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"},"builtins.Exception","builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.retry.RequestHistory._NT","id":-1,"name":"_NT","namespace":"urllib3.util.retry.RequestHistory.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.Exception",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"},"builtins.Exception","builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_asdict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["_self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.retry.RequestHistory._asdict","name":"_asdict","original_first_arg":"_self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["_self"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.retry.RequestHistory._NT","id":-1,"name":"_NT","namespace":"urllib3.util.retry.RequestHistory._asdict","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.Exception",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"},"builtins.Exception","builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_asdict of RequestHistory","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.retry.RequestHistory._NT","id":-1,"name":"_NT","namespace":"urllib3.util.retry.RequestHistory._asdict","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.Exception",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"},"builtins.Exception","builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_field_defaults":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"urllib3.util.retry.RequestHistory._field_defaults","name":"_field_defaults","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_field_types":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"urllib3.util.retry.RequestHistory._field_types","name":"_field_types","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_fields":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"urllib3.util.retry.RequestHistory._fields","name":"_fields","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_make":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["_cls","iterable"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated"],"fullname":"urllib3.util.retry.RequestHistory._make","name":"_make","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["_cls","iterable"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.retry.RequestHistory._NT","id":-1,"name":"_NT","namespace":"urllib3.util.retry.RequestHistory._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.Exception",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"},"builtins.Exception","builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_make of RequestHistory","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.retry.RequestHistory._NT","id":-1,"name":"_NT","namespace":"urllib3.util.retry.RequestHistory._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.Exception",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"},"builtins.Exception","builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.retry.RequestHistory._NT","id":-1,"name":"_NT","namespace":"urllib3.util.retry.RequestHistory._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.Exception",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"},"builtins.Exception","builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_classmethod","is_ready"],"fullname":"urllib3.util.retry.RequestHistory._make","name":"_make","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["_cls","iterable"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.retry.RequestHistory._NT","id":-1,"name":"_NT","namespace":"urllib3.util.retry.RequestHistory._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.Exception",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"},"builtins.Exception","builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_make of RequestHistory","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.retry.RequestHistory._NT","id":-1,"name":"_NT","namespace":"urllib3.util.retry.RequestHistory._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.Exception",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"},"builtins.Exception","builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.retry.RequestHistory._NT","id":-1,"name":"_NT","namespace":"urllib3.util.retry.RequestHistory._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.Exception",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"},"builtins.Exception","builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}}},"plugin_generated":true},"_replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5,5],"arg_names":["_self","method","url","error","status","redirect_location"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.retry.RequestHistory._replace","name":"_replace","original_first_arg":"_self","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5,5],"arg_names":["_self","method","url","error","status","redirect_location"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.retry.RequestHistory._NT","id":-1,"name":"_NT","namespace":"urllib3.util.retry.RequestHistory._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.Exception",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"},"builtins.Exception","builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.Exception",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_replace of RequestHistory","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.retry.RequestHistory._NT","id":-1,"name":"_NT","namespace":"urllib3.util.retry.RequestHistory._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.Exception",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"},"builtins.Exception","builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.retry.RequestHistory._NT","id":-1,"name":"_NT","namespace":"urllib3.util.retry.RequestHistory._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.Exception",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"},"builtins.Exception","builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_source":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"urllib3.util.retry.RequestHistory._source","name":"_source","setter_type":null,"type":"builtins.str"}},"error":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"urllib3.util.retry.RequestHistory.error","name":"error","setter_type":null,"type":{".class":"UnionType","items":["builtins.Exception",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"error-redefinition":{".class":"SymbolTableNode","cross_ref":"urllib3.util.retry.RequestHistory.error","kind":"Mdef"},"method":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"urllib3.util.retry.RequestHistory.method","name":"method","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"method-redefinition":{".class":"SymbolTableNode","cross_ref":"urllib3.util.retry.RequestHistory.method","kind":"Mdef"},"redirect_location":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"urllib3.util.retry.RequestHistory.redirect_location","name":"redirect_location","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"redirect_location-redefinition":{".class":"SymbolTableNode","cross_ref":"urllib3.util.retry.RequestHistory.redirect_location","kind":"Mdef"},"status":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"urllib3.util.retry.RequestHistory.status","name":"status","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"status-redefinition":{".class":"SymbolTableNode","cross_ref":"urllib3.util.retry.RequestHistory.status","kind":"Mdef"},"url":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"urllib3.util.retry.RequestHistory.url","name":"url","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"url-redefinition":{".class":"SymbolTableNode","cross_ref":"urllib3.util.retry.RequestHistory.url","kind":"Mdef"}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.retry.RequestHistory.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.Exception",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":"urllib3.util.retry.RequestHistory"},"values":[],"variance":0},"slots":null,"tuple_type":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.Exception",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"},"builtins.Exception","builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_vars":[],"typeddict_type":null}},"ResponseError":{".class":"SymbolTableNode","cross_ref":"urllib3.exceptions.ResponseError","kind":"Gdef"},"Retry":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"urllib3.util.retry.Retry","name":"Retry","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"urllib3.util.retry.Retry","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"urllib3.util.retry","mro":["urllib3.util.retry.Retry","builtins.object"],"names":{".class":"SymbolTable","DEFAULT":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_classvar","is_ready"],"fullname":"urllib3.util.retry.Retry.DEFAULT","name":"DEFAULT","setter_type":null,"type":"urllib3.util.retry.Retry"}},"DEFAULT_ALLOWED_METHODS":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.retry.Retry.DEFAULT_ALLOWED_METHODS","name":"DEFAULT_ALLOWED_METHODS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.frozenset"}}},"DEFAULT_BACKOFF_MAX":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.retry.Retry.DEFAULT_BACKOFF_MAX","name":"DEFAULT_BACKOFF_MAX","setter_type":null,"type":"builtins.int"}},"DEFAULT_REMOVE_HEADERS_ON_REDIRECT":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.retry.Retry.DEFAULT_REMOVE_HEADERS_ON_REDIRECT","name":"DEFAULT_REMOVE_HEADERS_ON_REDIRECT","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.frozenset"}}},"RETRY_AFTER_STATUS_CODES":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.retry.Retry.RETRY_AFTER_STATUS_CODES","name":"RETRY_AFTER_STATUS_CODES","setter_type":null,"type":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.frozenset"}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],"arg_names":["self","total","connect","read","redirect","status","other","allowed_methods","status_forcelist","backoff_factor","backoff_max","raise_on_redirect","raise_on_status","history","respect_retry_after_header","remove_headers_on_redirect","backoff_jitter"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.retry.Retry.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],"arg_names":["self","total","connect","read","redirect","status","other","allowed_methods","status_forcelist","backoff_factor","backoff_max","raise_on_redirect","raise_on_status","history","respect_retry_after_header","remove_headers_on_redirect","backoff_jitter"],"arg_types":["urllib3.util.retry.Retry",{".class":"UnionType","items":["builtins.bool","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Collection"},{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Collection"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.float","builtins.float","builtins.bool","builtins.bool",{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"urllib3.util.retry.RequestHistory"}],"extra_attrs":null,"type_ref":"builtins.tuple"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Collection"},"builtins.float"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of Retry","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.retry.Retry.__repr__","name":"__repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["urllib3.util.retry.Retry"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr__ of Retry","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_is_connection_error":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","err"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.retry.Retry._is_connection_error","name":"_is_connection_error","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","err"],"arg_types":["urllib3.util.retry.Retry","builtins.Exception"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_is_connection_error of Retry","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_is_method_retryable":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","method"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.retry.Retry._is_method_retryable","name":"_is_method_retryable","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","method"],"arg_types":["urllib3.util.retry.Retry","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_is_method_retryable of Retry","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_is_read_error":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","err"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.retry.Retry._is_read_error","name":"_is_read_error","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","err"],"arg_types":["urllib3.util.retry.Retry","builtins.Exception"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_is_read_error of Retry","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_sleep_backoff":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.retry.Retry._sleep_backoff","name":"_sleep_backoff","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.util.retry.Retry"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_sleep_backoff of Retry","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"allowed_methods":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.util.retry.Retry.allowed_methods","name":"allowed_methods","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Collection"},{".class":"NoneType"}],"uses_pep604_syntax":true}}},"backoff_factor":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.util.retry.Retry.backoff_factor","name":"backoff_factor","setter_type":null,"type":"builtins.float"}},"backoff_jitter":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.util.retry.Retry.backoff_jitter","name":"backoff_jitter","setter_type":null,"type":"builtins.float"}},"backoff_max":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.util.retry.Retry.backoff_max","name":"backoff_max","setter_type":null,"type":"builtins.float"}},"connect":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.util.retry.Retry.connect","name":"connect","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"from_int":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["cls","retries","redirect","default"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"urllib3.util.retry.Retry.from_int","name":"from_int","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["cls","retries","redirect","default"],"arg_types":[{".class":"TypeType","item":"urllib3.util.retry.Retry"},{".class":"UnionType","items":["urllib3.util.retry.Retry","builtins.bool","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["urllib3.util.retry.Retry","builtins.bool","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"from_int of Retry","ret_type":"urllib3.util.retry.Retry","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"urllib3.util.retry.Retry.from_int","name":"from_int","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["cls","retries","redirect","default"],"arg_types":[{".class":"TypeType","item":"urllib3.util.retry.Retry"},{".class":"UnionType","items":["urllib3.util.retry.Retry","builtins.bool","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bool","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["urllib3.util.retry.Retry","builtins.bool","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"from_int of Retry","ret_type":"urllib3.util.retry.Retry","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"get_backoff_time":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.retry.Retry.get_backoff_time","name":"get_backoff_time","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.util.retry.Retry"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_backoff_time of Retry","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"get_retry_after":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","response"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.retry.Retry.get_retry_after","name":"get_retry_after","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","response"],"arg_types":["urllib3.util.retry.Retry","urllib3.response.BaseHTTPResponse"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_retry_after of Retry","ret_type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"history":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.util.retry.Retry.history","name":"history","setter_type":null,"type":{".class":"Instance","args":[{".class":"TypeAliasType","args":[],"type_ref":"urllib3.util.retry.RequestHistory"}],"extra_attrs":null,"type_ref":"builtins.tuple"}}},"increment":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1],"arg_names":["self","method","url","response","error","_pool","_stacktrace"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.retry.Retry.increment","name":"increment","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1],"arg_names":["self","method","url","response","error","_pool","_stacktrace"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.retry.Retry.Self","id":0,"name":"Self","namespace":"","upper_bound":"urllib3.util.retry.Retry","values":[],"variance":0},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["urllib3.response.BaseHTTPResponse",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.Exception",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["urllib3.connectionpool.ConnectionPool",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["types.TracebackType",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"increment of Retry","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.retry.Retry.Self","id":0,"name":"Self","namespace":"","upper_bound":"urllib3.util.retry.Retry","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.retry.Retry.Self","id":0,"name":"Self","namespace":"","upper_bound":"urllib3.util.retry.Retry","values":[],"variance":0}]}}},"is_exhausted":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.retry.Retry.is_exhausted","name":"is_exhausted","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.util.retry.Retry"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_exhausted of Retry","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"is_retry":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["self","method","status_code","has_retry_after"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.retry.Retry.is_retry","name":"is_retry","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["self","method","status_code","has_retry_after"],"arg_types":["urllib3.util.retry.Retry","builtins.str","builtins.int","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_retry of Retry","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"new":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,4],"arg_names":["self","kw"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.retry.Retry.new","name":"new","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,4],"arg_names":["self","kw"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.retry.Retry.Self","id":0,"name":"Self","namespace":"","upper_bound":"urllib3.util.retry.Retry","values":[],"variance":0},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"new of Retry","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.retry.Retry.Self","id":0,"name":"Self","namespace":"","upper_bound":"urllib3.util.retry.Retry","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.retry.Retry.Self","id":0,"name":"Self","namespace":"","upper_bound":"urllib3.util.retry.Retry","values":[],"variance":0}]}}},"other":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.util.retry.Retry.other","name":"other","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"parse_retry_after":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","retry_after"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.retry.Retry.parse_retry_after","name":"parse_retry_after","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","retry_after"],"arg_types":["urllib3.util.retry.Retry","builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parse_retry_after of Retry","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"raise_on_redirect":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.util.retry.Retry.raise_on_redirect","name":"raise_on_redirect","setter_type":null,"type":"builtins.bool"}},"raise_on_status":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.util.retry.Retry.raise_on_status","name":"raise_on_status","setter_type":null,"type":"builtins.bool"}},"read":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.util.retry.Retry.read","name":"read","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"redirect":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.util.retry.Retry.redirect","name":"redirect","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"remove_headers_on_redirect":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.util.retry.Retry.remove_headers_on_redirect","name":"remove_headers_on_redirect","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.frozenset"}}},"respect_retry_after_header":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.util.retry.Retry.respect_retry_after_header","name":"respect_retry_after_header","setter_type":null,"type":"builtins.bool"}},"sleep":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","response"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.retry.Retry.sleep","name":"sleep","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","response"],"arg_types":["urllib3.util.retry.Retry",{".class":"UnionType","items":["urllib3.response.BaseHTTPResponse",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sleep of Retry","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"sleep_for_retry":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","response"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.retry.Retry.sleep_for_retry","name":"sleep_for_retry","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","response"],"arg_types":["urllib3.util.retry.Retry","urllib3.response.BaseHTTPResponse"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sleep_for_retry of Retry","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"status":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.util.retry.Retry.status","name":"status","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"status_forcelist":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.util.retry.Retry.status_forcelist","name":"status_forcelist","setter_type":null,"type":{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"typing.Collection"}}},"total":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.util.retry.Retry.total","name":"total","setter_type":null,"type":{".class":"UnionType","items":["builtins.bool","builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.retry.Retry.Self","id":0,"name":"Self","namespace":"","upper_bound":"urllib3.util.retry.Retry","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"Self":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Self","kind":"Gdef"},"TracebackType":{".class":"SymbolTableNode","cross_ref":"types.TracebackType","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.retry.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.retry.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.retry.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.retry.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.retry.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.retry.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"email":{".class":"SymbolTableNode","cross_ref":"email","kind":"Gdef"},"log":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.retry.log","name":"log","setter_type":null,"type":"logging.Logger"}},"logging":{".class":"SymbolTableNode","cross_ref":"logging","kind":"Gdef"},"random":{".class":"SymbolTableNode","cross_ref":"random","kind":"Gdef"},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef"},"reraise":{".class":"SymbolTableNode","cross_ref":"urllib3.util.util.reraise","kind":"Gdef"},"takewhile":{".class":"SymbolTableNode","cross_ref":"itertools.takewhile","kind":"Gdef"},"time":{".class":"SymbolTableNode","cross_ref":"time","kind":"Gdef"},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/urllib3/util/retry.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/retry.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/retry.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..82e63ed0c6a46e6e5ee1abc2523b149c5771f621 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/retry.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[21,12,26,27,1,3,4,5,6,7,8,9,10,24,1,1,1,1,1],"dep_prios":[5,5,25,25,5,10,10,10,10,10,10,5,5,25,5,30,30,30,30],"dependencies":["urllib3.util.util","urllib3.exceptions","urllib3.connectionpool","urllib3.response","__future__","email","logging","random","re","time","typing","itertools","types","typing_extensions","builtins","_frozen_importlib","_io","abc","io"],"hash":"c718dec62fedd1780fbde1b9f6c96b4460a5383f","id":"urllib3.util.retry","ignore_all":true,"interface_hash":"15a166c4d736947831763e9461c279b0063b22fe","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/urllib3/util/retry.py","plugin_data":null,"size":18459,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/ssl_.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/ssl_.data.json new file mode 100644 index 0000000000000000000000000000000000000000..b2e5b3b367255075389a231edc9449ac3c476722 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/ssl_.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"urllib3.util.ssl_","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","ALPN_PROTOCOLS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.ssl_.ALPN_PROTOCOLS","name":"ALPN_PROTOCOLS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"CERT_REQUIRED":{".class":"SymbolTableNode","cross_ref":"ssl.CERT_REQUIRED","kind":"Gdef"},"HASHFUNC_MAP":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.ssl_.HASHFUNC_MAP","name":"HASHFUNC_MAP","setter_type":null,"type":{".class":"Instance","args":["builtins.int",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"HAS_NEVER_CHECK_COMMON_NAME":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.ssl_.HAS_NEVER_CHECK_COMMON_NAME","name":"HAS_NEVER_CHECK_COMMON_NAME","setter_type":null,"type":"builtins.bool"}},"IS_PYOPENSSL":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.ssl_.IS_PYOPENSSL","name":"IS_PYOPENSSL","setter_type":null,"type":"builtins.bool"}},"OPENSSL_VERSION":{".class":"SymbolTableNode","cross_ref":"_ssl.OPENSSL_VERSION","kind":"Gdef"},"OPENSSL_VERSION_NUMBER":{".class":"SymbolTableNode","cross_ref":"_ssl.OPENSSL_VERSION_NUMBER","kind":"Gdef"},"OP_NO_COMPRESSION":{".class":"SymbolTableNode","cross_ref":"ssl.OP_NO_COMPRESSION","kind":"Gdef"},"OP_NO_SSLv2":{".class":"SymbolTableNode","cross_ref":"ssl.OP_NO_SSLv2","kind":"Gdef"},"OP_NO_SSLv3":{".class":"SymbolTableNode","cross_ref":"ssl.OP_NO_SSLv3","kind":"Gdef"},"OP_NO_TICKET":{".class":"SymbolTableNode","cross_ref":"ssl.OP_NO_TICKET","kind":"Gdef"},"PROTOCOL_SSLv23":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.ssl_.PROTOCOL_SSLv23","name":"PROTOCOL_SSLv23","setter_type":null,"type":"ssl._SSLMethod"}},"PROTOCOL_TLS":{".class":"SymbolTableNode","cross_ref":"ssl.PROTOCOL_TLS","kind":"Gdef"},"PROTOCOL_TLS_CLIENT":{".class":"SymbolTableNode","cross_ref":"ssl.PROTOCOL_TLS_CLIENT","kind":"Gdef"},"ProxySchemeUnsupported":{".class":"SymbolTableNode","cross_ref":"urllib3.exceptions.ProxySchemeUnsupported","kind":"Gdef"},"SSLContext":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.ssl_.SSLContext","name":"SSLContext","setter_type":null,"type":{".class":"NoneType"}}},"SSLError":{".class":"SymbolTableNode","cross_ref":"urllib3.exceptions.SSLError","kind":"Gdef"},"SSLTransport":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.ssl_.SSLTransport","name":"SSLTransport","setter_type":null,"type":{".class":"NoneType"}}},"SSLTransportType":{".class":"SymbolTableNode","cross_ref":"urllib3.util.ssltransport.SSLTransport","kind":"Gdef"},"TLSVersion":{".class":"SymbolTableNode","cross_ref":"ssl.TLSVersion","kind":"Gdef"},"TypedDict":{".class":"SymbolTableNode","cross_ref":"typing.TypedDict","kind":"Gdef"},"VERIFY_X509_PARTIAL_CHAIN":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.ssl_.VERIFY_X509_PARTIAL_CHAIN","name":"VERIFY_X509_PARTIAL_CHAIN","setter_type":null,"type":{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"builtins.int"],"uses_pep604_syntax":false}}},"VERIFY_X509_STRICT":{".class":"SymbolTableNode","cross_ref":"ssl.VERIFY_X509_STRICT","kind":"Gdef"},"VerifyMode":{".class":"SymbolTableNode","cross_ref":"ssl.VerifyMode","kind":"Gdef"},"_BRACELESS_IPV6_ADDRZ_RE":{".class":"SymbolTableNode","cross_ref":"urllib3.util.url._BRACELESS_IPV6_ADDRZ_RE","kind":"Gdef"},"_IPV4_RE":{".class":"SymbolTableNode","cross_ref":"urllib3.util.url._IPV4_RE","kind":"Gdef"},"_SSL_VERSION_TO_TLS_VERSION":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","has_explicit_value"],"fullname":"urllib3.util.ssl_._SSL_VERSION_TO_TLS_VERSION","name":"_SSL_VERSION_TO_TLS_VERSION","setter_type":null,"type":{".class":"Instance","args":["builtins.int","builtins.int"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_TYPE_PEER_CERT_RET":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"urllib3.util.ssl_._TYPE_PEER_CERT_RET","line":149,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"urllib3.util.ssl_._TYPE_PEER_CERT_RET_DICT"},"builtins.bytes",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"_TYPE_PEER_CERT_RET_DICT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["typing._TypedDict"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"urllib3.util.ssl_._TYPE_PEER_CERT_RET_DICT","name":"_TYPE_PEER_CERT_RET_DICT","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"urllib3.util.ssl_._TYPE_PEER_CERT_RET_DICT","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"urllib3.util.ssl_","mro":["urllib3.util.ssl_._TYPE_PEER_CERT_RET_DICT","typing._TypedDict","typing.Mapping","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable"},"self_type":null,"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":{".class":"TypedDictType","fallback":"typing._TypedDict","items":[["subjectAltName",{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"builtins.tuple"}],["subject",{".class":"Instance","args":[{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"extra_attrs":null,"type_ref":"builtins.tuple"}],["serialNumber","builtins.str"]],"readonly_keys":[],"required_keys":[]}}},"_TYPE_VERSION_INFO":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"urllib3.util.ssl_._TYPE_VERSION_INFO","line":21,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"TupleType","implicit":false,"items":["builtins.int","builtins.int","builtins.int","builtins.str","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.ssl_.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.ssl_.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.ssl_.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.ssl_.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.ssl_.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.ssl_.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_is_bpo_43522_fixed":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["implementation_name","version_info","pypy_version_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.ssl_._is_bpo_43522_fixed","name":"_is_bpo_43522_fixed","original_first_arg":"implementation_name","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["implementation_name","version_info","pypy_version_info"],"arg_types":["builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"urllib3.util.ssl_._TYPE_VERSION_INFO"},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"urllib3.util.ssl_._TYPE_VERSION_INFO"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_is_bpo_43522_fixed","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_is_has_never_check_common_name_reliable":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0],"arg_names":["openssl_version","openssl_version_number","implementation_name","version_info","pypy_version_info"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.ssl_._is_has_never_check_common_name_reliable","name":"_is_has_never_check_common_name_reliable","original_first_arg":"openssl_version","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0],"arg_names":["openssl_version","openssl_version_number","implementation_name","version_info","pypy_version_info"],"arg_types":["builtins.str","builtins.int","builtins.str",{".class":"TypeAliasType","args":[],"type_ref":"urllib3.util.ssl_._TYPE_VERSION_INFO"},{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"urllib3.util.ssl_._TYPE_VERSION_INFO"},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_is_has_never_check_common_name_reliable","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_is_key_file_encrypted":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["key_file"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.ssl_._is_key_file_encrypted","name":"_is_key_file_encrypted","original_first_arg":"key_file","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["key_file"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_is_key_file_encrypted","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_ssl_wrap_socket_impl":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1],"arg_names":["sock","ssl_context","tls_in_tls","server_hostname"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.ssl_._ssl_wrap_socket_impl","name":"_ssl_wrap_socket_impl","original_first_arg":"sock","type":{".class":"CallableType","arg_kinds":[0,0,0,1],"arg_names":["sock","ssl_context","tls_in_tls","server_hostname"],"arg_types":["socket.socket","ssl.SSLContext","builtins.bool",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_ssl_wrap_socket_impl","ret_type":{".class":"UnionType","items":["ssl.SSLSocket","urllib3.util.ssltransport.SSLTransport"],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"assert_fingerprint":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cert","fingerprint"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.ssl_.assert_fingerprint","name":"assert_fingerprint","original_first_arg":"cert","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cert","fingerprint"],"arg_types":[{".class":"UnionType","items":["builtins.bytes",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"assert_fingerprint","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"attr":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_index_var","is_ready","is_inferred"],"fullname":"urllib3.util.ssl_.attr","name":"attr","setter_type":null,"type":{".class":"UnionType","items":[{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.str","value":"TLSv1"},"type_ref":"builtins.str"},{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.str","value":"TLSv1_1"},"type_ref":"builtins.str"},{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.str","value":"TLSv1_2"},"type_ref":"builtins.str"}],"uses_pep604_syntax":false}}},"create_urllib3_context":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[1,1,1,1,1,1,1],"arg_names":["ssl_version","cert_reqs","options","ciphers","ssl_minimum_version","ssl_maximum_version","verify_flags"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.ssl_.create_urllib3_context","name":"create_urllib3_context","original_first_arg":"ssl_version","type":{".class":"CallableType","arg_kinds":[1,1,1,1,1,1,1],"arg_names":["ssl_version","cert_reqs","options","ciphers","ssl_minimum_version","ssl_maximum_version","verify_flags"],"arg_types":[{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"create_urllib3_context","ret_type":"ssl.SSLContext","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"hashlib":{".class":"SymbolTableNode","cross_ref":"hashlib","kind":"Gdef"},"hmac":{".class":"SymbolTableNode","cross_ref":"hmac","kind":"Gdef"},"is_ipaddress":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["hostname"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.ssl_.is_ipaddress","name":"is_ipaddress","original_first_arg":"hostname","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["hostname"],"arg_types":[{".class":"UnionType","items":["builtins.str","builtins.bytes"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"is_ipaddress","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"os":{".class":"SymbolTableNode","cross_ref":"os","kind":"Gdef"},"resolve_cert_reqs":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["candidate"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.ssl_.resolve_cert_reqs","name":"resolve_cert_reqs","original_first_arg":"candidate","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["candidate"],"arg_types":[{".class":"UnionType","items":[{".class":"NoneType"},"builtins.int","builtins.str"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"resolve_cert_reqs","ret_type":"ssl.VerifyMode","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"resolve_ssl_version":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["candidate"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.ssl_.resolve_ssl_version","name":"resolve_ssl_version","original_first_arg":"candidate","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["candidate"],"arg_types":[{".class":"UnionType","items":[{".class":"NoneType"},"builtins.int","builtins.str"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"resolve_ssl_version","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"socket":{".class":"SymbolTableNode","cross_ref":"socket","kind":"Gdef"},"ssl":{".class":"SymbolTableNode","cross_ref":"ssl","kind":"Gdef"},"ssl_wrap_socket":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"urllib3.util.ssl_.ssl_wrap_socket","impl":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1,1,1,1,1,1,1],"arg_names":["sock","keyfile","certfile","cert_reqs","ca_certs","server_hostname","ssl_version","ciphers","ssl_context","ca_cert_dir","key_password","ca_cert_data","tls_in_tls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload"],"fullname":"urllib3.util.ssl_.ssl_wrap_socket","name":"ssl_wrap_socket","original_first_arg":"sock","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,1,1,1,1,1,1],"arg_names":["sock","keyfile","certfile","cert_reqs","ca_certs","server_hostname","ssl_version","ciphers","ssl_context","ca_cert_dir","key_password","ca_cert_data","tls_in_tls"],"arg_types":["socket.socket",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"NoneType"},"builtins.str","builtins.bytes"],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ssl_wrap_socket","ret_type":{".class":"UnionType","items":["ssl.SSLSocket","urllib3.util.ssltransport.SSLTransport"],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1,1,1,1,1,1,1],"arg_names":["sock","keyfile","certfile","cert_reqs","ca_certs","server_hostname","ssl_version","ciphers","ssl_context","ca_cert_dir","key_password","ca_cert_data","tls_in_tls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"urllib3.util.ssl_.ssl_wrap_socket","name":"ssl_wrap_socket","original_first_arg":"sock","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,1,1,1,1,1,1],"arg_names":["sock","keyfile","certfile","cert_reqs","ca_certs","server_hostname","ssl_version","ciphers","ssl_context","ca_cert_dir","key_password","ca_cert_data","tls_in_tls"],"arg_types":["socket.socket",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"NoneType"},"builtins.str","builtins.bytes"],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ssl_wrap_socket","ret_type":"ssl.SSLSocket","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.util.ssl_.ssl_wrap_socket","name":"ssl_wrap_socket","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,1,1,1,1,1,1],"arg_names":["sock","keyfile","certfile","cert_reqs","ca_certs","server_hostname","ssl_version","ciphers","ssl_context","ca_cert_dir","key_password","ca_cert_data","tls_in_tls"],"arg_types":["socket.socket",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"NoneType"},"builtins.str","builtins.bytes"],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ssl_wrap_socket","ret_type":"ssl.SSLSocket","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1,1,1,1,1,1,1],"arg_names":["sock","keyfile","certfile","cert_reqs","ca_certs","server_hostname","ssl_version","ciphers","ssl_context","ca_cert_dir","key_password","ca_cert_data","tls_in_tls"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"urllib3.util.ssl_.ssl_wrap_socket","name":"ssl_wrap_socket","original_first_arg":"sock","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,1,1,1,1,1,1],"arg_names":["sock","keyfile","certfile","cert_reqs","ca_certs","server_hostname","ssl_version","ciphers","ssl_context","ca_cert_dir","key_password","ca_cert_data","tls_in_tls"],"arg_types":["socket.socket",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"NoneType"},"builtins.str","builtins.bytes"],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ssl_wrap_socket","ret_type":{".class":"UnionType","items":["ssl.SSLSocket","urllib3.util.ssltransport.SSLTransport"],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.util.ssl_.ssl_wrap_socket","name":"ssl_wrap_socket","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,1,1,1,1,1,1],"arg_names":["sock","keyfile","certfile","cert_reqs","ca_certs","server_hostname","ssl_version","ciphers","ssl_context","ca_cert_dir","key_password","ca_cert_data","tls_in_tls"],"arg_types":["socket.socket",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"NoneType"},"builtins.str","builtins.bytes"],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ssl_wrap_socket","ret_type":{".class":"UnionType","items":["ssl.SSLSocket","urllib3.util.ssltransport.SSLTransport"],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,1,1,1,1,1,1],"arg_names":["sock","keyfile","certfile","cert_reqs","ca_certs","server_hostname","ssl_version","ciphers","ssl_context","ca_cert_dir","key_password","ca_cert_data","tls_in_tls"],"arg_types":["socket.socket",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"NoneType"},"builtins.str","builtins.bytes"],"uses_pep604_syntax":true},{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ssl_wrap_socket","ret_type":"ssl.SSLSocket","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,1,1,1,1,1,1],"arg_names":["sock","keyfile","certfile","cert_reqs","ca_certs","server_hostname","ssl_version","ciphers","ssl_context","ca_cert_dir","key_password","ca_cert_data","tls_in_tls"],"arg_types":["socket.socket",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["ssl.SSLContext",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":[{".class":"NoneType"},"builtins.str","builtins.bytes"],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"ssl_wrap_socket","ret_type":{".class":"UnionType","items":["ssl.SSLSocket","urllib3.util.ssltransport.SSLTransport"],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"sys":{".class":"SymbolTableNode","cross_ref":"sys","kind":"Gdef"},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef"},"unhexlify":{".class":"SymbolTableNode","cross_ref":"binascii.unhexlify","kind":"Gdef"},"warnings":{".class":"SymbolTableNode","cross_ref":"warnings","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/urllib3/util/ssl_.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/ssl_.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/ssl_.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..e2c1b78db65498c6d02ea970497ffec6d878b79c --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/ssl_.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[13,82,12,1,3,4,5,6,7,8,9,10,79,1,1,1,1,1,1,1,1],"dep_prios":[5,5,5,5,10,10,10,10,10,10,10,5,5,5,30,30,30,30,30,30,30],"dependencies":["urllib3.util.url","urllib3.util.ssltransport","urllib3.exceptions","__future__","hashlib","hmac","os","socket","sys","typing","warnings","binascii","ssl","builtins","_frozen_importlib","_socket","_ssl","_typeshed","abc","enum","types"],"hash":"6cbba8bab83671e13052cae8fa5a8e136fee4516","id":"urllib3.util.ssl_","ignore_all":true,"interface_hash":"48cab0fa3b6dcd7e2826e3c3a027e66917cf755a","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/urllib3/util/ssl_.py","plugin_data":null,"size":19786,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/ssl_match_hostname.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/ssl_match_hostname.data.json new file mode 100644 index 0000000000000000000000000000000000000000..c0c6199b2eb1db2df2f473387bb6b724341a1209 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/ssl_match_hostname.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"urllib3.util.ssl_match_hostname","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","CertificateError":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.ValueError"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"urllib3.util.ssl_match_hostname.CertificateError","name":"CertificateError","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"urllib3.util.ssl_match_hostname.CertificateError","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"urllib3.util.ssl_match_hostname","mro":["urllib3.util.ssl_match_hostname.CertificateError","builtins.ValueError","builtins.Exception","builtins.BaseException","builtins.object"],"names":{".class":"SymbolTable"},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.ssl_match_hostname.CertificateError.Self","id":0,"name":"Self","namespace":"","upper_bound":"urllib3.util.ssl_match_hostname.CertificateError","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"IPv4Address":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv4Address","kind":"Gdef"},"IPv6Address":{".class":"SymbolTableNode","cross_ref":"ipaddress.IPv6Address","kind":"Gdef"},"_TYPE_PEER_CERT_RET_DICT":{".class":"SymbolTableNode","cross_ref":"urllib3.util.ssl_._TYPE_PEER_CERT_RET_DICT","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.ssl_match_hostname.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.ssl_match_hostname.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.ssl_match_hostname.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.ssl_match_hostname.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.ssl_match_hostname.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.ssl_match_hostname.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"__version__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.ssl_match_hostname.__version__","name":"__version__","setter_type":null,"type":"builtins.str"}},"_dnsname_match":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["dn","hostname","max_wildcards"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.ssl_match_hostname._dnsname_match","name":"_dnsname_match","original_first_arg":"dn","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["dn","hostname","max_wildcards"],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},"builtins.str","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_dnsname_match","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Match"},{".class":"NoneType"},"builtins.bool"],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_ipaddress_match":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["ipname","host_ip"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.ssl_match_hostname._ipaddress_match","name":"_ipaddress_match","original_first_arg":"ipname","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["ipname","host_ip"],"arg_types":["builtins.str",{".class":"UnionType","items":["ipaddress.IPv4Address","ipaddress.IPv6Address"],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_ipaddress_match","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"ipaddress":{".class":"SymbolTableNode","cross_ref":"ipaddress","kind":"Gdef"},"match_hostname":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["cert","hostname","hostname_checks_common_name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.ssl_match_hostname.match_hostname","name":"match_hostname","original_first_arg":"cert","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["cert","hostname","hostname_checks_common_name"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"urllib3.util.ssl_._TYPE_PEER_CERT_RET_DICT"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.str","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"match_hostname","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef"},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/urllib3/util/ssl_match_hostname.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/ssl_match_hostname.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/ssl_match_hostname.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..96e18bddba99fee581605612d676633c985ecad1 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/ssl_match_hostname.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[15,7,9,10,11,1,1,1],"dep_prios":[25,5,5,10,10,5,30,30],"dependencies":["urllib3.util.ssl_","__future__","ipaddress","re","typing","builtins","_frozen_importlib","abc"],"hash":"8800fc6261b5ab0389b6b4ff252c31ec33ca015e","id":"urllib3.util.ssl_match_hostname","ignore_all":true,"interface_hash":"ab50b5a736be4fc78e3213b0683cc22380092f51","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/urllib3/util/ssl_match_hostname.py","plugin_data":null,"size":5845,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/ssltransport.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/ssltransport.data.json new file mode 100644 index 0000000000000000000000000000000000000000..f6618acc58f3bd53a00927e422192b0561754e10 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/ssltransport.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"urllib3.util.ssltransport","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","ProxySchemeUnsupported":{".class":"SymbolTableNode","cross_ref":"urllib3.exceptions.ProxySchemeUnsupported","kind":"Gdef"},"SSLTransport":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"urllib3.util.ssltransport.SSLTransport","name":"SSLTransport","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"urllib3.util.ssltransport.SSLTransport","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"urllib3.util.ssltransport","mro":["urllib3.util.ssltransport.SSLTransport","builtins.object"],"names":{".class":"SymbolTable","__enter__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.ssltransport.SSLTransport.__enter__","name":"__enter__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.ssltransport.SSLTransport.Self","id":0,"name":"Self","namespace":"","upper_bound":"urllib3.util.ssltransport.SSLTransport","values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__enter__ of SSLTransport","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.ssltransport.SSLTransport.Self","id":0,"name":"Self","namespace":"","upper_bound":"urllib3.util.ssltransport.SSLTransport","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.ssltransport.SSLTransport.Self","id":0,"name":"Self","namespace":"","upper_bound":"urllib3.util.ssltransport.SSLTransport","values":[],"variance":0}]}}},"__exit__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,2],"arg_names":[null,null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.ssltransport.SSLTransport.__exit__","name":"__exit__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,2],"arg_names":[null,null],"arg_types":["urllib3.util.ssltransport.SSLTransport",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__exit__ of SSLTransport","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,1,1],"arg_names":["self","socket","ssl_context","server_hostname","suppress_ragged_eofs"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.ssltransport.SSLTransport.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,1,1],"arg_names":["self","socket","ssl_context","server_hostname","suppress_ragged_eofs"],"arg_types":["urllib3.util.ssltransport.SSLTransport","socket.socket","ssl.SSLContext",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of SSLTransport","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_decref_socketios":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.ssltransport.SSLTransport._decref_socketios","name":"_decref_socketios","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.util.ssltransport.SSLTransport"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_decref_socketios of SSLTransport","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_ssl_io_loop":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"urllib3.util.ssltransport.SSLTransport._ssl_io_loop","impl":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","func","arg1","arg2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_trivial_self"],"fullname":"urllib3.util.ssltransport.SSLTransport._ssl_io_loop","name":"_ssl_io_loop","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","func","arg1","arg2"],"arg_types":["urllib3.util.ssltransport.SSLTransport",{".class":"CallableType","arg_kinds":[2,4],"arg_names":[null,null],"arg_types":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":true,"name":null,"ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.ssltransport._ReturnValue","id":-1,"name":"_ReturnValue","namespace":"urllib3.util.ssltransport.SSLTransport._ssl_io_loop","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"UnionType","items":[{".class":"NoneType"},"builtins.bytes","builtins.int"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.bytearray",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_ssl_io_loop of SSLTransport","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.ssltransport._ReturnValue","id":-1,"name":"_ReturnValue","namespace":"urllib3.util.ssltransport.SSLTransport._ssl_io_loop","upper_bound":"builtins.object","values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.ssltransport._ReturnValue","id":-1,"name":"_ReturnValue","namespace":"urllib3.util.ssltransport.SSLTransport._ssl_io_loop","upper_bound":"builtins.object","values":[],"variance":0}]}},"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","func"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"urllib3.util.ssltransport.SSLTransport._ssl_io_loop","name":"_ssl_io_loop","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","func"],"arg_types":["urllib3.util.ssltransport.SSLTransport",{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_ssl_io_loop of SSLTransport","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.util.ssltransport.SSLTransport._ssl_io_loop","name":"_ssl_io_loop","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","func"],"arg_types":["urllib3.util.ssltransport.SSLTransport",{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_ssl_io_loop of SSLTransport","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["self","func","arg1"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"urllib3.util.ssltransport.SSLTransport._ssl_io_loop","name":"_ssl_io_loop","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","func","arg1"],"arg_types":["urllib3.util.ssltransport.SSLTransport",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.bytes"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"builtins.bytes"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_ssl_io_loop of SSLTransport","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.util.ssltransport.SSLTransport._ssl_io_loop","name":"_ssl_io_loop","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","func","arg1"],"arg_types":["urllib3.util.ssltransport.SSLTransport",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.bytes"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"builtins.bytes"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_ssl_io_loop of SSLTransport","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0],"arg_names":["self","func","arg1","arg2"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"urllib3.util.ssltransport.SSLTransport._ssl_io_loop","name":"_ssl_io_loop","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","func","arg1","arg2"],"arg_types":["urllib3.util.ssltransport.SSLTransport",{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.bytearray",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.bytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"builtins.int",{".class":"UnionType","items":["builtins.bytearray",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_ssl_io_loop of SSLTransport","ret_type":"builtins.bytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.util.ssltransport.SSLTransport._ssl_io_loop","name":"_ssl_io_loop","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","func","arg1","arg2"],"arg_types":["urllib3.util.ssltransport.SSLTransport",{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.bytearray",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.bytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"builtins.int",{".class":"UnionType","items":["builtins.bytearray",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_ssl_io_loop of SSLTransport","ret_type":"builtins.bytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","func"],"arg_types":["urllib3.util.ssltransport.SSLTransport",{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_ssl_io_loop of SSLTransport","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["self","func","arg1"],"arg_types":["urllib3.util.ssltransport.SSLTransport",{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["builtins.bytes"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"builtins.bytes"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_ssl_io_loop of SSLTransport","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0,0,0],"arg_names":["self","func","arg1","arg2"],"arg_types":["urllib3.util.ssltransport.SSLTransport",{".class":"CallableType","arg_kinds":[0,0],"arg_names":[null,null],"arg_types":["builtins.int",{".class":"UnionType","items":["builtins.bytearray",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.bytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},"builtins.int",{".class":"UnionType","items":["builtins.bytearray",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_ssl_io_loop of SSLTransport","ret_type":"builtins.bytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"_validate_ssl_context_for_tls_in_tls":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["ssl_context"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"urllib3.util.ssltransport.SSLTransport._validate_ssl_context_for_tls_in_tls","name":"_validate_ssl_context_for_tls_in_tls","original_first_arg":"ssl_context","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["ssl_context"],"arg_types":["ssl.SSLContext"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_validate_ssl_context_for_tls_in_tls of SSLTransport","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_staticmethod","is_ready","is_inferred"],"fullname":"urllib3.util.ssltransport.SSLTransport._validate_ssl_context_for_tls_in_tls","name":"_validate_ssl_context_for_tls_in_tls","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["ssl_context"],"arg_types":["ssl.SSLContext"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_validate_ssl_context_for_tls_in_tls of SSLTransport","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"_wrap_ssl_read":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","len","buffer"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.ssltransport.SSLTransport._wrap_ssl_read","name":"_wrap_ssl_read","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","len","buffer"],"arg_types":["urllib3.util.ssltransport.SSLTransport","builtins.int",{".class":"UnionType","items":["builtins.bytearray",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_wrap_ssl_read of SSLTransport","ret_type":{".class":"UnionType","items":["builtins.int","builtins.bytes"],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"cipher":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.ssltransport.SSLTransport.cipher","name":"cipher","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.util.ssltransport.SSLTransport"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"cipher of SSLTransport","ret_type":{".class":"UnionType","items":[{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"close":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.ssltransport.SSLTransport.close","name":"close","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.util.ssltransport.SSLTransport"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"close of SSLTransport","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"compression":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.ssltransport.SSLTransport.compression","name":"compression","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.util.ssltransport.SSLTransport"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"compression of SSLTransport","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"fileno":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.ssltransport.SSLTransport.fileno","name":"fileno","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.util.ssltransport.SSLTransport"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"fileno of SSLTransport","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"getpeercert":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"urllib3.util.ssltransport.SSLTransport.getpeercert","impl":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","binary_form"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_trivial_self"],"fullname":"urllib3.util.ssltransport.SSLTransport.getpeercert","name":"getpeercert","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","binary_form"],"arg_types":["urllib3.util.ssltransport.SSLTransport","builtins.bool"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getpeercert of SSLTransport","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"urllib3.util.ssl_._TYPE_PEER_CERT_RET"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["self","binary_form"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"urllib3.util.ssltransport.SSLTransport.getpeercert","name":"getpeercert","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","binary_form"],"arg_types":["urllib3.util.ssltransport.SSLTransport",{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getpeercert of SSLTransport","ret_type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"urllib3.util.ssl_._TYPE_PEER_CERT_RET_DICT"},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.util.ssltransport.SSLTransport.getpeercert","name":"getpeercert","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","binary_form"],"arg_types":["urllib3.util.ssltransport.SSLTransport",{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getpeercert of SSLTransport","ret_type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"urllib3.util.ssl_._TYPE_PEER_CERT_RET_DICT"},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","binary_form"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated","is_trivial_self"],"fullname":"urllib3.util.ssltransport.SSLTransport.getpeercert","name":"getpeercert","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","binary_form"],"arg_types":["urllib3.util.ssltransport.SSLTransport",{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getpeercert of SSLTransport","ret_type":{".class":"UnionType","items":["builtins.bytes",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.util.ssltransport.SSLTransport.getpeercert","name":"getpeercert","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","binary_form"],"arg_types":["urllib3.util.ssltransport.SSLTransport",{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getpeercert of SSLTransport","ret_type":{".class":"UnionType","items":["builtins.bytes",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,1],"arg_names":["self","binary_form"],"arg_types":["urllib3.util.ssltransport.SSLTransport",{".class":"LiteralType","fallback":"builtins.bool","value":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getpeercert of SSLTransport","ret_type":{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"urllib3.util.ssl_._TYPE_PEER_CERT_RET_DICT"},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","binary_form"],"arg_types":["urllib3.util.ssltransport.SSLTransport",{".class":"LiteralType","fallback":"builtins.bool","value":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"getpeercert of SSLTransport","ret_type":{".class":"UnionType","items":["builtins.bytes",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"gettimeout":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.ssltransport.SSLTransport.gettimeout","name":"gettimeout","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.util.ssltransport.SSLTransport"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"gettimeout of SSLTransport","ret_type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"incoming":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.util.ssltransport.SSLTransport.incoming","name":"incoming","setter_type":null,"type":"_ssl.MemoryBIO"}},"makefile":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,5,5,5],"arg_names":["self","mode","buffering","encoding","errors","newline"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.ssltransport.SSLTransport.makefile","name":"makefile","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,5,5,5],"arg_names":["self","mode","buffering","encoding","errors","newline"],"arg_types":["urllib3.util.ssltransport.SSLTransport","builtins.str",{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"makefile of SSLTransport","ret_type":{".class":"UnionType","items":["typing.BinaryIO","typing.TextIO","socket.SocketIO"],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"outgoing":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.util.ssltransport.SSLTransport.outgoing","name":"outgoing","setter_type":null,"type":"_ssl.MemoryBIO"}},"read":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["self","len","buffer"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.ssltransport.SSLTransport.read","name":"read","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","len","buffer"],"arg_types":["urllib3.util.ssltransport.SSLTransport","builtins.int",{".class":"UnionType","items":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":2},{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"read of SSLTransport","ret_type":{".class":"UnionType","items":["builtins.int","builtins.bytes"],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"recv":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["self","buflen","flags"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.ssltransport.SSLTransport.recv","name":"recv","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["self","buflen","flags"],"arg_types":["urllib3.util.ssltransport.SSLTransport","builtins.int","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"recv of SSLTransport","ret_type":{".class":"UnionType","items":["builtins.int","builtins.bytes"],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"recv_into":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1,1],"arg_names":["self","buffer","nbytes","flags"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.ssltransport.SSLTransport.recv_into","name":"recv_into","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1,1],"arg_names":["self","buffer","nbytes","flags"],"arg_types":["urllib3.util.ssltransport.SSLTransport",{".class":"TypeAliasType","args":[],"type_ref":"urllib3.util.ssltransport._WriteBuffer"},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"recv_into of SSLTransport","ret_type":{".class":"UnionType","items":[{".class":"NoneType"},"builtins.int","builtins.bytes"],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"selected_alpn_protocol":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.ssltransport.SSLTransport.selected_alpn_protocol","name":"selected_alpn_protocol","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.util.ssltransport.SSLTransport"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"selected_alpn_protocol of SSLTransport","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"send":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","data","flags"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.ssltransport.SSLTransport.send","name":"send","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","data","flags"],"arg_types":["urllib3.util.ssltransport.SSLTransport","builtins.bytes","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"send of SSLTransport","ret_type":"builtins.int","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"sendall":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["self","data","flags"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.ssltransport.SSLTransport.sendall","name":"sendall","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["self","data","flags"],"arg_types":["urllib3.util.ssltransport.SSLTransport","builtins.bytes","builtins.int"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"sendall of SSLTransport","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"settimeout":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["self","value"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.ssltransport.SSLTransport.settimeout","name":"settimeout","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["self","value"],"arg_types":["urllib3.util.ssltransport.SSLTransport",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"settimeout of SSLTransport","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"shared_ciphers":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.ssltransport.SSLTransport.shared_ciphers","name":"shared_ciphers","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.util.ssltransport.SSLTransport"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"shared_ciphers of SSLTransport","ret_type":{".class":"UnionType","items":[{".class":"Instance","args":[{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.int"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}],"extra_attrs":null,"type_ref":"builtins.list"},{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"socket":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.util.ssltransport.SSLTransport.socket","name":"socket","setter_type":null,"type":"socket.socket"}},"sslobj":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.util.ssltransport.SSLTransport.sslobj","name":"sslobj","setter_type":null,"type":"ssl.SSLObject"}},"suppress_ragged_eofs":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.util.ssltransport.SSLTransport.suppress_ragged_eofs","name":"suppress_ragged_eofs","setter_type":null,"type":"builtins.bool"}},"unwrap":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.ssltransport.SSLTransport.unwrap","name":"unwrap","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.util.ssltransport.SSLTransport"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"unwrap of SSLTransport","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"version":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.ssltransport.SSLTransport.version","name":"version","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.util.ssltransport.SSLTransport"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"version of SSLTransport","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.ssltransport.SSLTransport.Self","id":0,"name":"Self","namespace":"","upper_bound":"urllib3.util.ssltransport.SSLTransport","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"SSL_BLOCKSIZE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.ssltransport.SSL_BLOCKSIZE","name":"SSL_BLOCKSIZE","setter_type":null,"type":"builtins.int"}},"Self":{".class":"SymbolTableNode","cross_ref":"typing_extensions.Self","kind":"Gdef"},"_ReturnValue":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.ssltransport._ReturnValue","name":"_ReturnValue","upper_bound":"builtins.object","values":[],"variance":0}},"_TYPE_PEER_CERT_RET":{".class":"SymbolTableNode","cross_ref":"urllib3.util.ssl_._TYPE_PEER_CERT_RET","kind":"Gdef"},"_TYPE_PEER_CERT_RET_DICT":{".class":"SymbolTableNode","cross_ref":"urllib3.util.ssl_._TYPE_PEER_CERT_RET_DICT","kind":"Gdef"},"_WriteBuffer":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"urllib3.util.ssltransport._WriteBuffer","line":16,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["builtins.bytearray",{".class":"Instance","args":["builtins.int"],"extra_attrs":null,"type_ref":"builtins.memoryview"}],"uses_pep604_syntax":false}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.ssltransport.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.ssltransport.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.ssltransport.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.ssltransport.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.ssltransport.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.ssltransport.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"io":{".class":"SymbolTableNode","cross_ref":"io","kind":"Gdef"},"socket":{".class":"SymbolTableNode","cross_ref":"socket","kind":"Gdef"},"ssl":{".class":"SymbolTableNode","cross_ref":"ssl","kind":"Gdef"},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/urllib3/util/ssltransport.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/ssltransport.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/ssltransport.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..ecb6ae935a3944498deb6beec49aea3ec6d06e8f --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/ssltransport.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[13,8,1,3,4,5,6,11,1,1,1,1,1,1],"dep_prios":[25,5,5,10,10,10,10,25,5,30,30,30,30,30],"dependencies":["urllib3.util.ssl_","urllib3.exceptions","__future__","io","socket","ssl","typing","typing_extensions","builtins","_frozen_importlib","_io","_socket","_ssl","abc"],"hash":"0b242a4a768117e8d4164d6eaaf1f62d7698224e","id":"urllib3.util.ssltransport","ignore_all":true,"interface_hash":"0a90a337741e3715a72373d377a23257c69f732a","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/urllib3/util/ssltransport.py","plugin_data":null,"size":8847,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/timeout.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/timeout.data.json new file mode 100644 index 0000000000000000000000000000000000000000..3a5cda85bbef042c5681c5aa906da847b3cfdb0d --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/timeout.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"urllib3.util.timeout","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","Enum":{".class":"SymbolTableNode","cross_ref":"enum.Enum","kind":"Gdef"},"Final":{".class":"SymbolTableNode","cross_ref":"typing.Final","kind":"Gdef"},"Timeout":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["builtins.object"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"urllib3.util.timeout.Timeout","name":"Timeout","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"urllib3.util.timeout.Timeout","has_param_spec_type":false,"metaclass_type":null,"metadata":{},"module_name":"urllib3.util.timeout","mro":["urllib3.util.timeout.Timeout","builtins.object"],"names":{".class":"SymbolTable","DEFAULT_TIMEOUT":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","has_explicit_value"],"fullname":"urllib3.util.timeout.Timeout.DEFAULT_TIMEOUT","name":"DEFAULT_TIMEOUT","setter_type":null,"type":{".class":"TypeAliasType","args":[],"type_ref":"urllib3.util.timeout._TYPE_TIMEOUT"}}},"__init__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["self","total","connect","read"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.timeout.Timeout.__init__","name":"__init__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["self","total","connect","read"],"arg_types":["urllib3.util.timeout.Timeout",{".class":"UnionType","items":[{".class":"TypeAliasType","args":[],"type_ref":"urllib3.util.timeout._TYPE_TIMEOUT"},{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"TypeAliasType","args":[],"type_ref":"urllib3.util.timeout._TYPE_TIMEOUT"},{".class":"TypeAliasType","args":[],"type_ref":"urllib3.util.timeout._TYPE_TIMEOUT"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__init__ of Timeout","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__repr__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.timeout.Timeout.__repr__","name":"__repr__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["urllib3.util.timeout.Timeout"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__repr__ of Timeout","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__str__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.timeout.Timeout.__str__","name":"__str__","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":["urllib3.util.timeout.Timeout"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":null,"ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_connect":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.util.timeout.Timeout._connect","name":"_connect","setter_type":null,"type":{".class":"UnionType","items":["builtins.float","urllib3.util.timeout._TYPE_DEFAULT",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"_read":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.util.timeout.Timeout._read","name":"_read","setter_type":null,"type":{".class":"UnionType","items":["builtins.float","urllib3.util.timeout._TYPE_DEFAULT",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"_start_connect":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["explicit_self_type","is_ready","is_inferred"],"fullname":"urllib3.util.timeout.Timeout._start_connect","name":"_start_connect","setter_type":null,"type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}}},"_validate_timeout":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0],"arg_names":["cls","value","name"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"urllib3.util.timeout.Timeout._validate_timeout","name":"_validate_timeout","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["cls","value","name"],"arg_types":[{".class":"TypeType","item":"urllib3.util.timeout.Timeout"},{".class":"TypeAliasType","args":[],"type_ref":"urllib3.util.timeout._TYPE_TIMEOUT"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_validate_timeout of Timeout","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"urllib3.util.timeout._TYPE_TIMEOUT"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"urllib3.util.timeout.Timeout._validate_timeout","name":"_validate_timeout","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0,0],"arg_names":["cls","value","name"],"arg_types":[{".class":"TypeType","item":"urllib3.util.timeout.Timeout"},{".class":"TypeAliasType","args":[],"type_ref":"urllib3.util.timeout._TYPE_TIMEOUT"},"builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_validate_timeout of Timeout","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"urllib3.util.timeout._TYPE_TIMEOUT"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"clone":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.timeout.Timeout.clone","name":"clone","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.util.timeout.Timeout"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"clone of Timeout","ret_type":"urllib3.util.timeout.Timeout","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"connect_timeout":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"urllib3.util.timeout.Timeout.connect_timeout","name":"connect_timeout","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.util.timeout.Timeout"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"connect_timeout of Timeout","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"urllib3.util.timeout._TYPE_TIMEOUT"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"urllib3.util.timeout.Timeout.connect_timeout","name":"connect_timeout","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.util.timeout.Timeout"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"connect_timeout of Timeout","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"urllib3.util.timeout._TYPE_TIMEOUT"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"from_float":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["cls","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated","is_trivial_self"],"fullname":"urllib3.util.timeout.Timeout.from_float","name":"from_float","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","timeout"],"arg_types":[{".class":"TypeType","item":"urllib3.util.timeout.Timeout"},{".class":"TypeAliasType","args":[],"type_ref":"urllib3.util.timeout._TYPE_TIMEOUT"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"from_float of Timeout","ret_type":"urllib3.util.timeout.Timeout","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_classmethod","is_ready","is_inferred"],"fullname":"urllib3.util.timeout.Timeout.from_float","name":"from_float","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["cls","timeout"],"arg_types":[{".class":"TypeType","item":"urllib3.util.timeout.Timeout"},{".class":"TypeAliasType","args":[],"type_ref":"urllib3.util.timeout._TYPE_TIMEOUT"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"from_float of Timeout","ret_type":"urllib3.util.timeout.Timeout","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"get_connect_duration":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.timeout.Timeout.get_connect_duration","name":"get_connect_duration","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.util.timeout.Timeout"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"get_connect_duration of Timeout","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"read_timeout":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"urllib3.util.timeout.Timeout.read_timeout","name":"read_timeout","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.util.timeout.Timeout"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"read_timeout of Timeout","ret_type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"urllib3.util.timeout.Timeout.read_timeout","name":"read_timeout","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.util.timeout.Timeout"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"read_timeout of Timeout","ret_type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"resolve_default_timeout":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_decorated"],"fullname":"urllib3.util.timeout.Timeout.resolve_default_timeout","name":"resolve_default_timeout","original_first_arg":"timeout","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["timeout"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"urllib3.util.timeout._TYPE_TIMEOUT"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"resolve_default_timeout of Timeout","ret_type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_staticmethod","is_ready","is_inferred"],"fullname":"urllib3.util.timeout.Timeout.resolve_default_timeout","name":"resolve_default_timeout","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["timeout"],"arg_types":[{".class":"TypeAliasType","args":[],"type_ref":"urllib3.util.timeout._TYPE_TIMEOUT"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"resolve_default_timeout of Timeout","ret_type":{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"start_connect":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.timeout.Timeout.start_connect","name":"start_connect","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":["urllib3.util.timeout.Timeout"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"start_connect of Timeout","ret_type":"builtins.float","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"total":{".class":"SymbolTableNode","implicit":true,"kind":"Mdef","node":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.util.timeout.Timeout.total","name":"total","setter_type":null,"type":{".class":"UnionType","items":["builtins.float","urllib3.util.timeout._TYPE_DEFAULT",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.timeout.Timeout.Self","id":0,"name":"Self","namespace":"","upper_bound":"urllib3.util.timeout.Timeout","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"TimeoutStateError":{".class":"SymbolTableNode","cross_ref":"urllib3.exceptions.TimeoutStateError","kind":"Gdef"},"_DEFAULT_TIMEOUT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_final","is_ready","has_explicit_value"],"fullname":"urllib3.util.timeout._DEFAULT_TIMEOUT","name":"_DEFAULT_TIMEOUT","setter_type":null,"type":"urllib3.util.timeout._TYPE_DEFAULT"}},"_TYPE_DEFAULT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["enum.Enum"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"urllib3.util.timeout._TYPE_DEFAULT","name":"_TYPE_DEFAULT","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_enum"],"fullname":"urllib3.util.timeout._TYPE_DEFAULT","has_param_spec_type":false,"metaclass_type":"enum.EnumMeta","metadata":{},"module_name":"urllib3.util.timeout","mro":["urllib3.util.timeout._TYPE_DEFAULT","enum.Enum","builtins.object"],"names":{".class":"SymbolTable","token":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_final","is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.timeout._TYPE_DEFAULT.token","name":"token","setter_type":null,"type":{".class":"Instance","args":[],"extra_attrs":null,"last_known_value":{".class":"LiteralType","fallback":"builtins.int","value":-1},"type_ref":"builtins.int"}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.timeout._TYPE_DEFAULT.Self","id":0,"name":"Self","namespace":"","upper_bound":"urllib3.util.timeout._TYPE_DEFAULT","values":[],"variance":0},"slots":null,"tuple_type":null,"type_vars":[],"typeddict_type":null}},"_TYPE_TIMEOUT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeAlias","alias_tvars":[],"column":0,"fullname":"urllib3.util.timeout._TYPE_TIMEOUT","line":22,"no_args":false,"normalized":false,"python_3_12_type_alias":false,"target":{".class":"UnionType","items":["builtins.float","urllib3.util.timeout._TYPE_DEFAULT",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.timeout.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.timeout.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.timeout.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.timeout.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.timeout.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.timeout.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"getdefaulttimeout":{".class":"SymbolTableNode","cross_ref":"_socket.getdefaulttimeout","kind":"Gdef"},"time":{".class":"SymbolTableNode","cross_ref":"time","kind":"Gdef"},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/urllib3/util/timeout.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/timeout.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/timeout.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..ff41b10297b1f18743344623441fb967ea033849 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/timeout.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[8,1,3,4,5,6,1,1,1],"dep_prios":[5,5,10,10,5,5,5,30,30],"dependencies":["urllib3.exceptions","__future__","time","typing","enum","socket","builtins","_frozen_importlib","abc"],"hash":"166c5f455b7f05ad8d63687b29a0bf0724ebb2d5","id":"urllib3.util.timeout","ignore_all":true,"interface_hash":"93da09d498b04e439b8189b3bdeb0ad46ce5f494","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/urllib3/util/timeout.py","plugin_data":null,"size":10346,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/url.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/url.data.json new file mode 100644 index 0000000000000000000000000000000000000000..945c5185d02276fb36b9ff7ed18ac469bdeffedc --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/url.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"urllib3.util.url","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","LocationParseError":{".class":"SymbolTableNode","cross_ref":"urllib3.exceptions.LocationParseError","kind":"Gdef"},"Url":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":["urllib3.util.url.Url@81"],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"urllib3.util.url.Url","name":"Url","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":[],"fullname":"urllib3.util.url.Url","has_param_spec_type":false,"metaclass_type":"abc.ABCMeta","metadata":{},"module_name":"urllib3.util.url","mro":["urllib3.util.url.Url","urllib3.util.url.Url@81","builtins.tuple","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","__new__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1,1,1,1,1],"arg_names":["cls","scheme","auth","host","port","path","query","fragment"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static","is_trivial_self"],"fullname":"urllib3.util.url.Url.__new__","name":"__new__","original_first_arg":"cls","type":{".class":"CallableType","arg_kinds":[0,1,1,1,1,1,1,1],"arg_names":["cls","scheme","auth","host","port","path","query","fragment"],"arg_types":[{".class":"TypeType","item":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":"urllib3.util.url.Url"}},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of Url","ret_type":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":1},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"__str__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":[null],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_trivial_self"],"fullname":"urllib3.util.url.Url.__str__","name":"__str__","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":[null],"arg_types":[{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":"urllib3.util.url.Url"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__str__ of Url","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"authority":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"urllib3.util.url.Url.authority","name":"authority","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":"urllib3.util.url.Url"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"authority of Url","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"urllib3.util.url.Url.authority","name":"authority","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":"urllib3.util.url.Url"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"authority of Url","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"hostname":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"urllib3.util.url.Url.hostname","name":"hostname","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":"urllib3.util.url.Url"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hostname of Url","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"urllib3.util.url.Url.hostname","name":"hostname","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":"urllib3.util.url.Url"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"hostname of Url","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"netloc":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"urllib3.util.url.Url.netloc","name":"netloc","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":"urllib3.util.url.Url"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"netloc of Url","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"urllib3.util.url.Url.netloc","name":"netloc","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":"urllib3.util.url.Url"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"netloc of Url","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"request_uri":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"urllib3.util.url.Url.request_uri","name":"request_uri","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":"urllib3.util.url.Url"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"request_uri of Url","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"urllib3.util.url.Url.request_uri","name":"request_uri","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":"urllib3.util.url.Url"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"request_uri of Url","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"url":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["self"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_property","is_decorated","is_trivial_self"],"fullname":"urllib3.util.url.Url.url","name":"url","original_first_arg":"self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":"urllib3.util.url.Url"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"url of Url","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":false,"var":{".class":"Var","flags":["is_initialized_in_class","is_property","is_ready","is_inferred"],"fullname":"urllib3.util.url.Url.url","name":"url","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0],"arg_names":["self"],"arg_types":[{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":"urllib3.util.url.Url"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"url of Url","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}}},"self_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.url.Url.Self","id":0,"name":"Self","namespace":"","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":"urllib3.util.url.Url"},"values":[],"variance":0},"slots":null,"tuple_type":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":"urllib3.util.url.Url@81"},"type_vars":[],"typeddict_type":null}},"Url@81":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"TypeInfo","_promote":[],"abstract_attributes":[],"alt_promote":null,"bases":[{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"},"builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}],"dataclass_transform_spec":null,"declared_metaclass":null,"defn":{".class":"ClassDef","fullname":"urllib3.util.url.Url@81","name":"Url@81","type_vars":[]},"deletable_attributes":[],"deprecated":null,"flags":["is_named_tuple"],"fullname":"urllib3.util.url.Url@81","has_param_spec_type":false,"metaclass_type":null,"metadata":{"namedtuple":{"fields":["scheme","auth","host","port","path","query","fragment"]}},"module_name":"urllib3.util.url","mro":["urllib3.util.url.Url@81","builtins.tuple","typing.Sequence","typing.Reversible","typing.Collection","typing.Iterable","typing.Container","builtins.object"],"names":{".class":"SymbolTable","_NT":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"TypeVarExpr","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.url.Url@81._NT","name":"_NT","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"},"builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},"__annotations__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"urllib3.util.url.Url@81.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"urllib3.util.url.Url@81.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__new__":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,0,0,0,0,0,0],"arg_names":["_cls","scheme","auth","host","port","path","query","fragment"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_static"],"fullname":"urllib3.util.url.Url@81.__new__","name":"__new__","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[0,0,0,0,0,0,0,0],"arg_names":["_cls","scheme","auth","host","port","path","query","fragment"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.url.Url@81._NT","id":-1,"name":"_NT","namespace":"urllib3.util.url.Url@81.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"},"builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"__new__ of Url@81","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.url.Url@81._NT","id":-1,"name":"_NT","namespace":"urllib3.util.url.Url@81.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"},"builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.url.Url@81._NT","id":-1,"name":"_NT","namespace":"urllib3.util.url.Url@81.__new__","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"},"builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_asdict":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["_self"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.url.Url@81._asdict","name":"_asdict","original_first_arg":"_self","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["_self"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.url.Url@81._NT","id":-1,"name":"_NT","namespace":"urllib3.util.url.Url@81._asdict","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"},"builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_asdict of Url@81","ret_type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.url.Url@81._NT","id":-1,"name":"_NT","namespace":"urllib3.util.url.Url@81._asdict","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"},"builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_field_defaults":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"urllib3.util.url.Url@81._field_defaults","name":"_field_defaults","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_field_types":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"urllib3.util.url.Url@81._field_types","name":"_field_types","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_fields":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"urllib3.util.url.Url@81._fields","name":"_fields","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str","builtins.str"],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_make":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["_cls","iterable"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_class","is_decorated"],"fullname":"urllib3.util.url.Url@81._make","name":"_make","original_first_arg":"_cls","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["_cls","iterable"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.url.Url@81._NT","id":-1,"name":"_NT","namespace":"urllib3.util.url.Url@81._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"},"builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_make of Url@81","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.url.Url@81._NT","id":-1,"name":"_NT","namespace":"urllib3.util.url.Url@81._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"},"builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.url.Url@81._NT","id":-1,"name":"_NT","namespace":"urllib3.util.url.Url@81._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"},"builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"is_overload":false,"var":{".class":"Var","flags":["is_classmethod","is_ready"],"fullname":"urllib3.util.url.Url@81._make","name":"_make","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["_cls","iterable"],"arg_types":[{".class":"TypeType","item":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.url.Url@81._NT","id":-1,"name":"_NT","namespace":"urllib3.util.url.Url@81._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"},"builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}},{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"typing.Iterable"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_make of Url@81","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.url.Url@81._NT","id":-1,"name":"_NT","namespace":"urllib3.util.url.Url@81._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"},"builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.url.Url@81._NT","id":-1,"name":"_NT","namespace":"urllib3.util.url.Url@81._make","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"},"builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}}},"plugin_generated":true},"_replace":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,5,5,5,5,5,5,5],"arg_names":["_self","scheme","auth","host","port","path","query","fragment"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.url.Url@81._replace","name":"_replace","original_first_arg":"_self","type":{".class":"CallableType","arg_kinds":[0,5,5,5,5,5,5,5],"arg_names":["_self","scheme","auth","host","port","path","query","fragment"],"arg_types":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.url.Url@81._NT","id":-1,"name":"_NT","namespace":"urllib3.util.url.Url@81._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"},"builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_replace of Url@81","ret_type":{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.url.Url@81._NT","id":-1,"name":"_NT","namespace":"urllib3.util.url.Url@81._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"},"builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[{".class":"TypeVarType","default":{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":4},"fullname":"urllib3.util.url.Url@81._NT","id":-1,"name":"_NT","namespace":"urllib3.util.url.Url@81._replace","upper_bound":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"},"builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"values":[],"variance":0}]}},"plugin_generated":true},"_source":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_initialized_in_class","is_ready"],"fullname":"urllib3.util.url.Url@81._source","name":"_source","setter_type":null,"type":"builtins.str"}},"auth":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"urllib3.util.url.Url@81.auth","name":"auth","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"fragment":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"urllib3.util.url.Url@81.fragment","name":"fragment","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"host":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"urllib3.util.url.Url@81.host","name":"host","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"path":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"urllib3.util.url.Url@81.path","name":"path","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"port":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"urllib3.util.url.Url@81.port","name":"port","setter_type":null,"type":{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"query":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"urllib3.util.url.Url@81.query","name":"query","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}},"scheme":{".class":"SymbolTableNode","kind":"Mdef","node":{".class":"Var","flags":["is_property","is_ready"],"fullname":"urllib3.util.url.Url@81.scheme","name":"scheme","setter_type":null,"type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}}}},"self_type":null,"slots":null,"tuple_type":{".class":"TupleType","implicit":false,"items":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.int",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":false}],"partial_fallback":{".class":"Instance","args":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"},"builtins.int"],"uses_pep604_syntax":false}],"extra_attrs":null,"type_ref":"builtins.tuple"}},"type_vars":[],"typeddict_type":null}},"_BRACELESS_IPV6_ADDRZ_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.url._BRACELESS_IPV6_ADDRZ_RE","name":"_BRACELESS_IPV6_ADDRZ_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"_FRAGMENT_CHARS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.url._FRAGMENT_CHARS","name":"_FRAGMENT_CHARS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"_HEX_PAT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.url._HEX_PAT","name":"_HEX_PAT","setter_type":null,"type":"builtins.str"}},"_HOST_PORT_PAT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.url._HOST_PORT_PAT","name":"_HOST_PORT_PAT","setter_type":null,"type":"builtins.str"}},"_HOST_PORT_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.url._HOST_PORT_RE","name":"_HOST_PORT_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"_IPV4_PAT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.url._IPV4_PAT","name":"_IPV4_PAT","setter_type":null,"type":"builtins.str"}},"_IPV4_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.url._IPV4_RE","name":"_IPV4_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"_IPV6_ADDRZ_PAT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.url._IPV6_ADDRZ_PAT","name":"_IPV6_ADDRZ_PAT","setter_type":null,"type":"builtins.str"}},"_IPV6_ADDRZ_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.url._IPV6_ADDRZ_RE","name":"_IPV6_ADDRZ_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"_IPV6_PAT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.url._IPV6_PAT","name":"_IPV6_PAT","setter_type":null,"type":"builtins.str"}},"_IPV6_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.url._IPV6_RE","name":"_IPV6_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"_LS32_PAT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.url._LS32_PAT","name":"_LS32_PAT","setter_type":null,"type":"builtins.str"}},"_NORMALIZABLE_SCHEMES":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.url._NORMALIZABLE_SCHEMES","name":"_NORMALIZABLE_SCHEMES","setter_type":null,"type":{".class":"TupleType","implicit":false,"items":["builtins.str","builtins.str",{".class":"NoneType"}],"partial_fallback":{".class":"Instance","args":[{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.tuple"}}}},"_PATH_CHARS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.url._PATH_CHARS","name":"_PATH_CHARS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"_PERCENT_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.url._PERCENT_RE","name":"_PERCENT_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"_QUERY_CHARS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.url._QUERY_CHARS","name":"_QUERY_CHARS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"_REG_NAME_PAT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.url._REG_NAME_PAT","name":"_REG_NAME_PAT","setter_type":null,"type":"builtins.str"}},"_SCHEME_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.url._SCHEME_RE","name":"_SCHEME_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"_SUB_DELIM_CHARS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.url._SUB_DELIM_CHARS","name":"_SUB_DELIM_CHARS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"_TARGET_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.url._TARGET_RE","name":"_TARGET_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"_UNRESERVED_CHARS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.url._UNRESERVED_CHARS","name":"_UNRESERVED_CHARS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"_UNRESERVED_PAT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.url._UNRESERVED_PAT","name":"_UNRESERVED_PAT","setter_type":null,"type":"builtins.str"}},"_URI_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.url._URI_RE","name":"_URI_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"_USERINFO_CHARS":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.url._USERINFO_CHARS","name":"_USERINFO_CHARS","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.set"}}},"_ZONE_ID_PAT":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.url._ZONE_ID_PAT","name":"_ZONE_ID_PAT","setter_type":null,"type":"builtins.str"}},"_ZONE_ID_RE":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.url._ZONE_ID_RE","name":"_ZONE_ID_RE","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"re.Pattern"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.url.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.url.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.url.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.url.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.url.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.url.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_encode_invalid_chars":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"urllib3.util.url._encode_invalid_chars","impl":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["component","allowed_chars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload"],"fullname":"urllib3.util.url._encode_invalid_chars","name":"_encode_invalid_chars","original_first_arg":"component","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["component","allowed_chars"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Container"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_encode_invalid_chars","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["component","allowed_chars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"urllib3.util.url._encode_invalid_chars","name":"_encode_invalid_chars","original_first_arg":"component","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["component","allowed_chars"],"arg_types":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Container"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_encode_invalid_chars","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.util.url._encode_invalid_chars","name":"_encode_invalid_chars","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["component","allowed_chars"],"arg_types":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Container"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_encode_invalid_chars","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["component","allowed_chars"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"urllib3.util.url._encode_invalid_chars","name":"_encode_invalid_chars","original_first_arg":"component","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["component","allowed_chars"],"arg_types":[{".class":"NoneType"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Container"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_encode_invalid_chars","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.util.url._encode_invalid_chars","name":"_encode_invalid_chars","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["component","allowed_chars"],"arg_types":[{".class":"NoneType"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Container"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_encode_invalid_chars","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["component","allowed_chars"],"arg_types":["builtins.str",{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Container"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_encode_invalid_chars","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["component","allowed_chars"],"arg_types":[{".class":"NoneType"},{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"typing.Container"}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_encode_invalid_chars","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"_encode_target":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["target"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.url._encode_target","name":"_encode_target","original_first_arg":"target","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["target"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_encode_target","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_idna_encode":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["name"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.url._idna_encode","name":"_idna_encode","original_first_arg":"name","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["name"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_idna_encode","ret_type":"builtins.bytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_normalize_host":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"OverloadedFuncDef","deprecated":null,"flags":[],"fullname":"urllib3.util.url._normalize_host","impl":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["host","scheme"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload"],"fullname":"urllib3.util.url._normalize_host","name":"_normalize_host","original_first_arg":"host","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["host","scheme"],"arg_types":[{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_normalize_host","ret_type":{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"items":[{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["host","scheme"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"urllib3.util.url._normalize_host","name":"_normalize_host","original_first_arg":"host","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["host","scheme"],"arg_types":[{".class":"NoneType"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_normalize_host","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.util.url._normalize_host","name":"_normalize_host","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["host","scheme"],"arg_types":[{".class":"NoneType"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_normalize_host","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},{".class":"Decorator","func":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0],"arg_names":["host","scheme"],"dataclass_transform_spec":null,"deprecated":null,"flags":["is_overload","is_decorated"],"fullname":"urllib3.util.url._normalize_host","name":"_normalize_host","original_first_arg":"host","type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["host","scheme"],"arg_types":["builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_normalize_host","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}},"is_overload":true,"var":{".class":"Var","flags":["is_ready","is_inferred"],"fullname":"urllib3.util.url._normalize_host","name":"_normalize_host","setter_type":null,"type":{".class":"CallableType","arg_kinds":[0,0],"arg_names":["host","scheme"],"arg_types":["builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_normalize_host","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}],"setter_index":null,"type":{".class":"Overloaded","items":[{".class":"CallableType","arg_kinds":[0,0],"arg_names":["host","scheme"],"arg_types":[{".class":"NoneType"},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_normalize_host","ret_type":{".class":"NoneType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]},{".class":"CallableType","arg_kinds":[0,0],"arg_names":["host","scheme"],"arg_types":["builtins.str",{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_normalize_host","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}]}}},"_remove_path_dot_segments":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["path"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.url._remove_path_dot_segments","name":"_remove_path_dot_segments","original_first_arg":"path","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["path"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_remove_path_dot_segments","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"_subs":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.url._subs","name":"_subs","setter_type":null,"type":{".class":"Instance","args":["builtins.str","builtins.str"],"extra_attrs":null,"type_ref":"builtins.dict"}}},"_variations":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.url._variations","name":"_variations","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"parse_url":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0],"arg_names":["url"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.url.parse_url","name":"parse_url","original_first_arg":"url","type":{".class":"CallableType","arg_kinds":[0],"arg_names":["url"],"arg_types":["builtins.str"],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"parse_url","ret_type":{".class":"TypeAliasType","args":[],"type_ref":"urllib3.util.url.Url"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"re":{".class":"SymbolTableNode","cross_ref":"re","kind":"Gdef"},"to_str":{".class":"SymbolTableNode","cross_ref":"urllib3.util.util.to_str","kind":"Gdef"},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/urllib3/util/url.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/url.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/url.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..cf7a39fc99099242d43df8c1f607b2e3b05783e1 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/url.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106715,"dep_lines":[7,6,1,3,4,1,1,1,1],"dep_prios":[5,5,5,10,10,5,30,30,30],"dependencies":["urllib3.util.util","urllib3.exceptions","__future__","re","typing","builtins","_frozen_importlib","abc","enum"],"hash":"51d396146d087d3f2d1ec80b00837381c16c6352","id":"urllib3.util.url","ignore_all":true,"interface_hash":"48754087b8a3448cd3e1a12665afaf85d0e48e07","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/urllib3/util/url.py","plugin_data":null,"size":15205,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/util.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/util.data.json new file mode 100644 index 0000000000000000000000000000000000000000..9d025ba72b5f7e5d6269522ef9e8124e776c8d64 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/util.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"urllib3.util.util","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","TracebackType":{".class":"SymbolTableNode","cross_ref":"types.TracebackType","kind":"Gdef"},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.util.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.util.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.util.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.util.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.util.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.util.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef"},"reraise":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,0,1],"arg_names":["tp","value","tb"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.util.reraise","name":"reraise","original_first_arg":"tp","type":{".class":"CallableType","arg_kinds":[0,0,1],"arg_names":["tp","value","tb"],"arg_types":[{".class":"UnionType","items":[{".class":"TypeType","item":"builtins.BaseException"},{".class":"NoneType"}],"uses_pep604_syntax":true},"builtins.BaseException",{".class":"UnionType","items":["types.TracebackType",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"reraise","ret_type":{".class":"UninhabitedType"},"type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"to_bytes":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["x","encoding","errors"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.util.to_bytes","name":"to_bytes","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["x","encoding","errors"],"arg_types":[{".class":"UnionType","items":["builtins.str","builtins.bytes"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"to_bytes","ret_type":"builtins.bytes","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"to_str":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1],"arg_names":["x","encoding","errors"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.util.to_str","name":"to_str","original_first_arg":"x","type":{".class":"CallableType","arg_kinds":[0,1,1],"arg_names":["x","encoding","errors"],"arg_types":[{".class":"UnionType","items":["builtins.str","builtins.bytes"],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true},{".class":"UnionType","items":["builtins.str",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"to_str","ret_type":"builtins.str","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"typing":{".class":"SymbolTableNode","cross_ref":"typing","kind":"Gdef"}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/urllib3/util/util.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/util.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/util.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..e8e5daf463492f298395eddbf4b810359ed3e1c9 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/util.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106714,"dep_lines":[1,3,4,1,1,1],"dep_prios":[5,10,5,5,30,30],"dependencies":["__future__","typing","types","builtins","_frozen_importlib","abc"],"hash":"ac7a579ce7e37ce8bf215f97b9bfb80b149b0f68","id":"urllib3.util.util","ignore_all":true,"interface_hash":"573193bd0a2fef0c28af068b58a050dd9a5cdb45","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/urllib3/util/util.py","plugin_data":null,"size":1146,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/wait.data.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/wait.data.json new file mode 100644 index 0000000000000000000000000000000000000000..a2fe0cf27d10c2827959c3d811db64671a6f90e7 --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/wait.data.json @@ -0,0 +1 @@ +{".class":"MypyFile","_fullname":"urllib3.util.wait","future_import_flags":["annotations"],"is_partial_stub_package":false,"is_stub":false,"names":{".class":"SymbolTable","__all__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready","is_inferred","has_explicit_value"],"fullname":"urllib3.util.wait.__all__","name":"__all__","setter_type":null,"type":{".class":"Instance","args":["builtins.str"],"extra_attrs":null,"type_ref":"builtins.list"}}},"__annotations__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.wait.__annotations__","name":"__annotations__","setter_type":null,"type":{".class":"Instance","args":["builtins.str",{".class":"AnyType","missing_import_name":null,"source_any":null,"type_of_any":6}],"extra_attrs":null,"type_ref":"builtins.dict"}}},"__doc__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.wait.__doc__","name":"__doc__","setter_type":null,"type":"builtins.str"}},"__file__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.wait.__file__","name":"__file__","setter_type":null,"type":"builtins.str"}},"__name__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.wait.__name__","name":"__name__","setter_type":null,"type":"builtins.str"}},"__package__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.wait.__package__","name":"__package__","setter_type":null,"type":"builtins.str"}},"__spec__":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"Var","flags":["is_ready"],"fullname":"urllib3.util.wait.__spec__","name":"__spec__","setter_type":null,"type":"_frozen_importlib.ModuleSpec"}},"_have_working_poll":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[],"arg_names":[],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.wait._have_working_poll","name":"_have_working_poll","original_first_arg":null,"type":{".class":"CallableType","arg_kinds":[],"arg_names":[],"arg_types":[],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"_have_working_poll","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"annotations":{".class":"SymbolTableNode","cross_ref":"__future__.annotations","kind":"Gdef","module_public":false},"partial":{".class":"SymbolTableNode","cross_ref":"functools.partial","kind":"Gdef","module_public":false},"poll_wait_for_socket":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["sock","read","write","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.wait.poll_wait_for_socket","name":"poll_wait_for_socket","original_first_arg":"sock","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["sock","read","write","timeout"],"arg_types":["socket.socket","builtins.bool","builtins.bool",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"poll_wait_for_socket","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"select":{".class":"SymbolTableNode","cross_ref":"select","kind":"Gdef","module_public":false},"select_wait_for_socket":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["sock","read","write","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.wait.select_wait_for_socket","name":"select_wait_for_socket","original_first_arg":"sock","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["sock","read","write","timeout"],"arg_types":["socket.socket","builtins.bool","builtins.bool",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"select_wait_for_socket","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"socket":{".class":"SymbolTableNode","cross_ref":"socket","kind":"Gdef","module_public":false},"wait_for_read":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["sock","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.wait.wait_for_read","name":"wait_for_read","original_first_arg":"sock","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["sock","timeout"],"arg_types":["socket.socket",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"wait_for_read","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"wait_for_socket":{".class":"SymbolTableNode","kind":"Gdef","module_public":false,"node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1,1,1],"arg_names":["sock","read","write","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.wait.wait_for_socket","name":"wait_for_socket","original_first_arg":"sock","type":{".class":"CallableType","arg_kinds":[0,1,1,1],"arg_names":["sock","read","write","timeout"],"arg_types":["socket.socket","builtins.bool","builtins.bool",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"wait_for_socket","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}},"wait_for_write":{".class":"SymbolTableNode","kind":"Gdef","node":{".class":"FuncDef","abstract_status":0,"arg_kinds":[0,1],"arg_names":["sock","timeout"],"dataclass_transform_spec":null,"deprecated":null,"flags":[],"fullname":"urllib3.util.wait.wait_for_write","name":"wait_for_write","original_first_arg":"sock","type":{".class":"CallableType","arg_kinds":[0,1],"arg_names":["sock","timeout"],"arg_types":["socket.socket",{".class":"UnionType","items":["builtins.float",{".class":"NoneType"}],"uses_pep604_syntax":true}],"fallback":"builtins.function","from_concatenate":false,"implicit":false,"imprecise_arg_kinds":false,"is_bound":false,"is_ellipsis_args":false,"name":"wait_for_write","ret_type":"builtins.bool","type_guard":null,"type_is":null,"unpack_kwargs":false,"variables":[]}}}},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/urllib3/util/wait.py"} \ No newline at end of file diff --git a/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/wait.meta.json b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/wait.meta.json new file mode 100644 index 0000000000000000000000000000000000000000..8817e367b49acd07826be3ce1f62877392dda54a --- /dev/null +++ b/src/RoslynStone.GradioModule/.mypy_cache/3.9/urllib3/util/wait.meta.json @@ -0,0 +1 @@ +{"data_mtime":1764106714,"dep_lines":[1,3,4,5,1,1,1,1,1],"dep_prios":[5,10,10,5,5,30,30,30,30],"dependencies":["__future__","select","socket","functools","builtins","_frozen_importlib","_socket","abc","typing"],"hash":"b8ffb5126ab052a8798f03efb7bc3d8c1bd6837a","id":"urllib3.util.wait","ignore_all":true,"interface_hash":"29e2b3fa57c1d0f4759a0fc7b9ad603973cc72e1","mtime":1764093359,"options":{"allow_redefinition":false,"allow_redefinition_new":false,"allow_untyped_globals":false,"always_false":[],"always_true":[],"bazel":false,"check_untyped_defs":true,"disable_bytearray_promotion":false,"disable_error_code":[],"disable_memoryview_promotion":false,"disabled_error_codes":[],"disallow_any_decorated":false,"disallow_any_explicit":false,"disallow_any_expr":false,"disallow_any_generics":false,"disallow_any_unimported":false,"disallow_incomplete_defs":false,"disallow_subclassing_any":false,"disallow_untyped_calls":false,"disallow_untyped_decorators":false,"disallow_untyped_defs":false,"enable_error_code":[],"enabled_error_codes":[],"extra_checks":false,"fixed_format_cache":false,"follow_imports":"normal","follow_imports_for_stubs":false,"follow_untyped_imports":false,"ignore_errors":false,"ignore_missing_imports":false,"implicit_optional":true,"implicit_reexport":true,"local_partial_types":false,"mypyc":false,"old_type_inference":false,"platform":"linux","plugins":[],"strict_bytes":false,"strict_concatenate":false,"strict_equality":true,"strict_equality_for_none":false,"strict_optional":true,"warn_no_return":true,"warn_return_any":true,"warn_unreachable":true,"warn_unused_ignores":false},"path":"/workspaces/Rosyln-Stone/.venv/lib/python3.14/site-packages/urllib3/util/wait.py","plugin_data":null,"size":4423,"suppressed":[],"version_id":"1.18.2"} \ No newline at end of file diff --git a/src/RoslynStone.Infrastructure/bin/Debug/net10.0/RoslynStone.Infrastructure.dll b/src/RoslynStone.Infrastructure/bin/Debug/net10.0/RoslynStone.Infrastructure.dll new file mode 100644 index 0000000000000000000000000000000000000000..76ee6f2298e7678c4197a6f86d6153c00c8022a7 --- /dev/null +++ b/src/RoslynStone.Infrastructure/bin/Debug/net10.0/RoslynStone.Infrastructure.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:00a0b61802467df8f359300c8249cdb5fd216c327512c9366377b502b6cce9ea +size 310784 diff --git a/src/RoslynStone.Infrastructure/bin/Debug/net10.0/RoslynStone.Infrastructure.pdb b/src/RoslynStone.Infrastructure/bin/Debug/net10.0/RoslynStone.Infrastructure.pdb new file mode 100644 index 0000000000000000000000000000000000000000..f6244ad351db69e92782b047464b25742c03a82d --- /dev/null +++ b/src/RoslynStone.Infrastructure/bin/Debug/net10.0/RoslynStone.Infrastructure.pdb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:656bcc77cab20593d721461f1cf4f6b1ac2486c44c43439c762e4c2accaadc74 +size 117292 diff --git a/src/RoslynStone.Infrastructure/bin/Release/net10.0/RoslynStone.Infrastructure.dll b/src/RoslynStone.Infrastructure/bin/Release/net10.0/RoslynStone.Infrastructure.dll new file mode 100644 index 0000000000000000000000000000000000000000..e6e44c4edaec703173a8f0e486da35c91758c21a --- /dev/null +++ b/src/RoslynStone.Infrastructure/bin/Release/net10.0/RoslynStone.Infrastructure.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9bc528ce5f1d5d8e048660932a160750f7997ef8872c288bd0055f13fd6814c3 +size 290304 diff --git a/src/RoslynStone.Infrastructure/bin/Release/net10.0/RoslynStone.Infrastructure.pdb b/src/RoslynStone.Infrastructure/bin/Release/net10.0/RoslynStone.Infrastructure.pdb new file mode 100644 index 0000000000000000000000000000000000000000..0d5c9d6d7e38efe10d3931654770e154a280f5d2 --- /dev/null +++ b/src/RoslynStone.Infrastructure/bin/Release/net10.0/RoslynStone.Infrastructure.pdb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e550bf8c5dd24e186fc107cfa063a35e1ee21a875273d76654cbb11632767bb9 +size 105308 diff --git a/src/RoslynStone.Infrastructure/obj/Debug/net10.0/RoslynStone.Infrastructure.dll b/src/RoslynStone.Infrastructure/obj/Debug/net10.0/RoslynStone.Infrastructure.dll new file mode 100644 index 0000000000000000000000000000000000000000..76ee6f2298e7678c4197a6f86d6153c00c8022a7 --- /dev/null +++ b/src/RoslynStone.Infrastructure/obj/Debug/net10.0/RoslynStone.Infrastructure.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:00a0b61802467df8f359300c8249cdb5fd216c327512c9366377b502b6cce9ea +size 310784 diff --git a/src/RoslynStone.Infrastructure/obj/Debug/net10.0/RoslynStone.Infrastructure.pdb b/src/RoslynStone.Infrastructure/obj/Debug/net10.0/RoslynStone.Infrastructure.pdb new file mode 100644 index 0000000000000000000000000000000000000000..f6244ad351db69e92782b047464b25742c03a82d --- /dev/null +++ b/src/RoslynStone.Infrastructure/obj/Debug/net10.0/RoslynStone.Infrastructure.pdb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:656bcc77cab20593d721461f1cf4f6b1ac2486c44c43439c762e4c2accaadc74 +size 117292 diff --git a/src/RoslynStone.Infrastructure/obj/Release/net10.0/RoslynStone.Infrastructure.dll b/src/RoslynStone.Infrastructure/obj/Release/net10.0/RoslynStone.Infrastructure.dll new file mode 100644 index 0000000000000000000000000000000000000000..e6e44c4edaec703173a8f0e486da35c91758c21a --- /dev/null +++ b/src/RoslynStone.Infrastructure/obj/Release/net10.0/RoslynStone.Infrastructure.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9bc528ce5f1d5d8e048660932a160750f7997ef8872c288bd0055f13fd6814c3 +size 290304 diff --git a/src/RoslynStone.Infrastructure/obj/Release/net10.0/RoslynStone.Infrastructure.pdb b/src/RoslynStone.Infrastructure/obj/Release/net10.0/RoslynStone.Infrastructure.pdb new file mode 100644 index 0000000000000000000000000000000000000000..0d5c9d6d7e38efe10d3931654770e154a280f5d2 --- /dev/null +++ b/src/RoslynStone.Infrastructure/obj/Release/net10.0/RoslynStone.Infrastructure.pdb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e550bf8c5dd24e186fc107cfa063a35e1ee21a875273d76654cbb11632767bb9 +size 105308 diff --git a/tests/RoslynStone.AppHost.Tests/AppHostTests.cs b/tests/RoslynStone.AppHost.Tests/AppHostTests.cs new file mode 100644 index 0000000000000000000000000000000000000000..9169a449540341ec7b85cdc0319a45c35df7d5d9 --- /dev/null +++ b/tests/RoslynStone.AppHost.Tests/AppHostTests.cs @@ -0,0 +1,137 @@ +using Aspire.Hosting; +using Aspire.Hosting.ApplicationModel; +using Aspire.Hosting.Testing; + +namespace RoslynStone.AppHost.Tests; + +/// +/// Integration tests for the Roslyn-Stone AppHost Aspire configuration. +/// These tests verify that the distributed application starts correctly and +/// that the MCP server HTTP endpoint is accessible. +/// +[Trait("Category", "Integration")] +[Trait("Component", "Aspire")] +public class AppHostTests +{ + [Fact] + public async Task AppHost_CreatesSuccessfully() + { + // Arrange & Act + var appHost = + await DistributedApplicationTestingBuilder.CreateAsync(); + + // Assert + Assert.NotNull(appHost); + } + + [Fact] + public async Task McpServer_HasHttpEndpoint() + { + // Arrange + var appHost = + await DistributedApplicationTestingBuilder.CreateAsync(); + + // Act + var mcpServer = appHost + .Resources.OfType() + .FirstOrDefault(r => r.Name == "roslyn-stone-mcp"); + + // Assert + Assert.NotNull(mcpServer); + var endpoints = mcpServer.GetEndpoints(); + // The MCP server uses the default 'http' endpoint; ensure it's present. + Assert.Contains(endpoints, e => e.EndpointName == "http"); + } + + [Fact] + public async Task McpServer_HasCorrectEnvironmentVariables() + { + // Arrange + var appHost = + await DistributedApplicationTestingBuilder.CreateAsync(); + + // Act + var mcpServer = appHost + .Resources.OfType() + .FirstOrDefault(r => r.Name == "roslyn-stone-mcp"); + + // Assert + Assert.NotNull(mcpServer); + var env = await mcpServer.GetEnvironmentVariableValuesAsync( + DistributedApplicationOperation.Publish + ); + + Assert.True(env.TryGetValue("MCP_TRANSPORT", out var mcpTransport)); + Assert.Equal("http", mcpTransport); + Assert.True(env.TryGetValue("OTEL_SERVICE_NAME", out var otelServiceName)); + Assert.Equal("roslyn-stone-mcp", otelServiceName); + } + + [Fact] + public async Task McpServer_IsConfiguredAsProjectResource() + { + // Arrange + var appHost = + await DistributedApplicationTestingBuilder.CreateAsync(); + + // Act + var mcpServer = appHost.Resources.FirstOrDefault(r => r.Name == "roslyn-stone-mcp"); + + // Assert + Assert.NotNull(mcpServer); + Assert.IsAssignableFrom(mcpServer); + } + + [Fact] + public async Task McpServer_DoesNotHaveStdioTransport() + { + // Arrange + var appHost = + await DistributedApplicationTestingBuilder.CreateAsync(); + + // Act - there should only be one resource named "roslyn-stone-mcp" + var mcpServers = appHost + .Resources.Where(r => + r.Name.Contains("roslyn-stone-mcp", StringComparison.OrdinalIgnoreCase) + ) + .ToList(); + + // Assert - verify only HTTP transport is configured (no stdio) + Assert.Single(mcpServers); + Assert.Equal("roslyn-stone-mcp", mcpServers[0].Name); + } + + [Fact] + public async Task McpInspector_IsConfiguredInDevelopment() + { + // Arrange + var appHost = + await DistributedApplicationTestingBuilder.CreateAsync(); + + // Act + var inspector = appHost.Resources.FirstOrDefault(r => r.Name == "mcp-inspector"); + + // Assert - inspector should be present in development mode (default for tests) + Assert.NotNull(inspector); + Assert.IsAssignableFrom(inspector); + } + + [Fact] + public async Task McpInspector_HasUiAndProxyEndpoints() + { + // Arrange + var appHost = + await DistributedApplicationTestingBuilder.CreateAsync(); + + // Act + var inspector = appHost + .Resources.OfType() + .FirstOrDefault(r => r.Name == "mcp-inspector"); + + // Assert + Assert.NotNull(inspector); + var endpoints = inspector.GetEndpoints().ToList(); + Assert.Contains(endpoints, e => e.EndpointName == "client"); + Assert.Contains(endpoints, e => e.EndpointName == "server-proxy"); + } +} diff --git a/tests/RoslynStone.AppHost.Tests/RoslynStone.AppHost.Tests.csproj b/tests/RoslynStone.AppHost.Tests/RoslynStone.AppHost.Tests.csproj new file mode 100644 index 0000000000000000000000000000000000000000..938cd25e2c7256d3f4afc4f0db68c47dbcc90cfc --- /dev/null +++ b/tests/RoslynStone.AppHost.Tests/RoslynStone.AppHost.Tests.csproj @@ -0,0 +1,25 @@ + + + net10.0 + enable + enable + false + + + + + + + + + + + + + + + + + + + diff --git a/tests/RoslynStone.Benchmarks/CompilationServiceBenchmarks.cs b/tests/RoslynStone.Benchmarks/CompilationServiceBenchmarks.cs new file mode 100644 index 0000000000000000000000000000000000000000..025a1841e0648f6c2e0bd9dd549d11c805c026fc --- /dev/null +++ b/tests/RoslynStone.Benchmarks/CompilationServiceBenchmarks.cs @@ -0,0 +1,81 @@ +using BenchmarkDotNet.Attributes; +using RoslynStone.Infrastructure.Services; + +namespace RoslynStone.Benchmarks; + +[MemoryDiagnoser] +[MinColumn, MaxColumn, MeanColumn, MedianColumn] +public class CompilationServiceBenchmarks +{ + private CompilationService _service = null!; + + [GlobalSetup] + public void Setup() + { + _service = new CompilationService(); + } + + [Benchmark] + public bool CompileSimpleClass() + { + var result = _service.Compile( + @" + using System; + public class TestClass + { + public int Add(int a, int b) => a + b; + } + " + ); + return result.Success; + } + + [Benchmark] + public bool CompileComplexCode() + { + var result = _service.Compile( + @" + using System; + using System.Collections.Generic; + using System.Linq; + + public class Calculator + { + public int Sum(IEnumerable numbers) => numbers.Sum(); + public double Average(IEnumerable numbers) => numbers.Average(); + public int Max(IEnumerable numbers) => numbers.Max(); + } + " + ); + return result.Success; + } + + [Benchmark] + public bool CompileWithError() + { + var result = _service.Compile("int x = \"string\";"); + return result.Success; + } + + [Benchmark] + public bool CompileMultipleClasses() + { + var result = _service.Compile( + @" + using System; + + public class Person + { + public string Name { get; set; } + public int Age { get; set; } + } + + public class PersonService + { + public bool IsAdult(Person person) => person.Age >= 18; + } + " + ); + return result.Success; + } +} diff --git a/tests/RoslynStone.Benchmarks/NuGetServiceBenchmarks.cs b/tests/RoslynStone.Benchmarks/NuGetServiceBenchmarks.cs new file mode 100644 index 0000000000000000000000000000000000000000..81fd1075694d2bfdaf234f9052a79ff5e60df66c --- /dev/null +++ b/tests/RoslynStone.Benchmarks/NuGetServiceBenchmarks.cs @@ -0,0 +1,44 @@ +using BenchmarkDotNet.Attributes; +using RoslynStone.Infrastructure.Services; + +namespace RoslynStone.Benchmarks; + +[MemoryDiagnoser] +[MinColumn, MaxColumn, MeanColumn, MedianColumn] +public class NuGetServiceBenchmarks +{ + private NuGetService _service = null!; + + [GlobalSetup] + public void Setup() + { + _service = new NuGetService(); + } + + [GlobalCleanup] + public void Cleanup() + { + _service.Dispose(); + } + + [Benchmark] + public async Task SearchPackages() + { + var result = await _service.SearchPackagesAsync("Newtonsoft.Json", 0, 10); + return result.Packages.Count; + } + + [Benchmark] + public async Task GetPackageVersions() + { + var versions = await _service.GetPackageVersionsAsync("Newtonsoft.Json"); + return versions.Count; + } + + [Benchmark] + public async Task GetPackageReadme() + { + var readme = await _service.GetPackageReadmeAsync("Newtonsoft.Json"); + return readme; + } +} diff --git a/tests/RoslynStone.Benchmarks/Program.cs b/tests/RoslynStone.Benchmarks/Program.cs new file mode 100644 index 0000000000000000000000000000000000000000..cc2aee6885324c578631db5e5f7ffa62336f2f22 --- /dev/null +++ b/tests/RoslynStone.Benchmarks/Program.cs @@ -0,0 +1,11 @@ +using BenchmarkDotNet.Running; + +namespace RoslynStone.Benchmarks; + +public class Program +{ + public static void Main(string[] args) + { + BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args); + } +} diff --git a/tests/RoslynStone.Benchmarks/README.md b/tests/RoslynStone.Benchmarks/README.md new file mode 100644 index 0000000000000000000000000000000000000000..d74c73ca0dff3fbb4e9631131af93ab2ce1394d9 --- /dev/null +++ b/tests/RoslynStone.Benchmarks/README.md @@ -0,0 +1,57 @@ +# Roslyn-Stone Benchmarks + +This project contains performance benchmarks for Roslyn-Stone using [BenchmarkDotNet](https://benchmarkdotnet.org/). + +## Running Benchmarks + +### Run All Benchmarks + +```bash +dotnet run --project tests/RoslynStone.Benchmarks --configuration Release +``` + +### Run Specific Benchmark + +```bash +dotnet run --project tests/RoslynStone.Benchmarks --configuration Release -- --filter *RoslynScriptingServiceBenchmarks* +``` + +### Using Cake Build Script + +```bash +dotnet cake --target=Benchmark +``` + +## Available Benchmarks + +### RoslynScriptingServiceBenchmarks +- `ExecuteSimpleExpression` - Basic arithmetic operations +- `ExecuteVariableAssignment` - Variable declaration and usage +- `ExecuteLinqQuery` - LINQ query execution +- `ExecuteComplexExpression` - Complex data structure manipulation +- `ExecuteWithStringManipulation` - String operations + +### CompilationServiceBenchmarks +- `ValidateSimpleExpression` - Code validation of simple expressions +- `ValidateComplexCode` - Code validation of complex code blocks +- `ValidateWithError` - Validation with compilation errors +- `CompileToAssembly` - Full assembly compilation + +### NuGetServiceBenchmarks +- `SearchPackages` - Package search operations +- `GetPackageVersions` - Retrieve package version information +- `GetPackageReadme` - Fetch package README files + +## Benchmark Results + +Benchmark results are saved to `./artifacts/benchmarks/` and include: +- Execution times (Min, Max, Mean, Median) +- Memory allocations +- Statistical analysis + +## Tips + +- Always run benchmarks in **Release** configuration +- Close other applications to minimize interference +- Run multiple iterations for consistent results +- Compare results across different machines cautiously diff --git a/tests/RoslynStone.Benchmarks/RoslynScriptingServiceBenchmarks.cs b/tests/RoslynStone.Benchmarks/RoslynScriptingServiceBenchmarks.cs new file mode 100644 index 0000000000000000000000000000000000000000..ad5ff952b51bc8de694ece019c358c7b6f4def14 --- /dev/null +++ b/tests/RoslynStone.Benchmarks/RoslynScriptingServiceBenchmarks.cs @@ -0,0 +1,64 @@ +using BenchmarkDotNet.Attributes; +using RoslynStone.Infrastructure.Services; + +namespace RoslynStone.Benchmarks; + +[MemoryDiagnoser] +[MinColumn, MaxColumn, MeanColumn, MedianColumn] +public class RoslynScriptingServiceBenchmarks +{ + private RoslynScriptingService _service = null!; + + [GlobalSetup] + public void Setup() + { + _service = new RoslynScriptingService(); + } + + [Benchmark] + public async Task ExecuteSimpleExpression() + { + var result = await _service.ExecuteAsync("2 + 2"); + return result.ReturnValue; + } + + [Benchmark] + public async Task ExecuteVariableAssignment() + { + var result = await _service.ExecuteAsync("var x = 10; x * 2"); + return result.ReturnValue; + } + + [Benchmark] + public async Task ExecuteLinqQuery() + { + var result = await _service.ExecuteAsync( + "Enumerable.Range(1, 100).Where(x => x % 2 == 0).Sum()" + ); + return result.ReturnValue; + } + + [Benchmark] + public async Task ExecuteComplexExpression() + { + var result = await _service.ExecuteAsync( + @" + var list = new List { 1, 2, 3, 4, 5 }; + list.Select(x => x * x).ToList() + " + ); + return result.ReturnValue; + } + + [Benchmark] + public async Task ExecuteWithStringManipulation() + { + var result = await _service.ExecuteAsync( + @" + var text = ""Hello, World!""; + text.ToUpper().Replace(""WORLD"", ""BENCHMARKS"") + " + ); + return result.ReturnValue; + } +} diff --git a/tests/RoslynStone.Benchmarks/RoslynStone.Benchmarks.csproj b/tests/RoslynStone.Benchmarks/RoslynStone.Benchmarks.csproj new file mode 100644 index 0000000000000000000000000000000000000000..f81cf213e1b3d395d430c5440b3bb0af92d23abd --- /dev/null +++ b/tests/RoslynStone.Benchmarks/RoslynStone.Benchmarks.csproj @@ -0,0 +1,20 @@ + + + net10.0 + 14 + enable + enable + Exe + false + true + + + + + + + + + + + diff --git a/tests/RoslynStone.GradioTests/GradioLandingPagePlaywrightTests.cs b/tests/RoslynStone.GradioTests/GradioLandingPagePlaywrightTests.cs new file mode 100644 index 0000000000000000000000000000000000000000..919cf25bd85bb7b9403e2549621b999ea9177f9b --- /dev/null +++ b/tests/RoslynStone.GradioTests/GradioLandingPagePlaywrightTests.cs @@ -0,0 +1,269 @@ +using Microsoft.Playwright; + +namespace RoslynStone.GradioTests; + +/// +/// Playwright-based integration tests for Gradio landing page. +/// Uses Microsoft.Playwright.Xunit for proper async test handling. +/// Runs in separate collection from HttpClient tests to avoid blocking. +/// +[Collection("Playwright")] +[Trait("Category", "Integration")] +[Trait("Component", "Gradio")] +public class GradioLandingPagePlaywrightTests : IAsyncLifetime +{ + private readonly McpServerFixture _fixture; + private readonly PlaywrightFixture _playwrightFixture; + + public GradioLandingPagePlaywrightTests( + McpServerFixture fixture, + PlaywrightFixture playwrightFixture + ) + { + _fixture = fixture; + _playwrightFixture = playwrightFixture; + } + + public Task InitializeAsync() + { + Console.WriteLine("[PLAYWRIGHT TEST] Test initialized"); + return Task.CompletedTask; + } + + public Task DisposeAsync() + { + Console.WriteLine("[PLAYWRIGHT TEST] Test cleanup"); + return Task.CompletedTask; + } + + [Fact] + public async Task GradioLandingPage_ShouldLoad_WithPlaywright() + { + // Create a new browser context and page for this test + var context = await _playwrightFixture.Browser!.NewContextAsync(); + var page = await context.NewPageAsync(); + + try + { + Console.WriteLine($"[PLAYWRIGHT] Navigating to {_fixture.GradioUrl}"); + + // Navigate to the Gradio landing page with timeout + // Use Load instead of NetworkIdle because Gradio has continuous SSE connections + var response = await page.GotoAsync( + _fixture.GradioUrl, + new PageGotoOptions { WaitUntil = WaitUntilState.Load, Timeout = 30000 } + ); + + Assert.NotNull(response); + Assert.True(response.Ok, $"Expected successful response, got {response.Status}"); + + Console.WriteLine($"[PLAYWRIGHT] Page loaded with status {response.Status}"); + + // Wait for Gradio app to initialize + await page.WaitForSelectorAsync( + "gradio-app", + new PageWaitForSelectorOptions { Timeout = 10000 } + ); + + // Verify page content contains expected text + var content = await page.ContentAsync(); + Console.WriteLine($"[PLAYWRIGHT] Page content length: {content.Length}"); + Assert.Contains("Roslyn", content, StringComparison.OrdinalIgnoreCase); + Assert.Contains("MCP", content, StringComparison.OrdinalIgnoreCase); + + // Take a screenshot for debugging (saved to test output) + await page.ScreenshotAsync( + new PageScreenshotOptions + { + Path = Path.Combine(AppContext.BaseDirectory, "gradio-landing-page.png"), + FullPage = true, + } + ); + + Console.WriteLine("[PLAYWRIGHT] Test completed successfully"); + } + finally + { + await page.CloseAsync(); + await context.CloseAsync(); + } + } + + [Fact] + public async Task GradioLandingPage_ShouldHave_ExpectedElements() + { + var context = await _playwrightFixture.Browser!.NewContextAsync(); + var page = await context.NewPageAsync(); + + try + { + await page.GotoAsync( + _fixture.GradioUrl, + new PageGotoOptions { WaitUntil = WaitUntilState.Load, Timeout = 30000 } + ); + + // Check for Gradio app container + var gradioApp = await page.QuerySelectorAsync("gradio-app"); + Assert.NotNull(gradioApp); + + // Check for main content sections + var content = await page.ContentAsync(); + Assert.Contains("Roslyn", content, StringComparison.OrdinalIgnoreCase); + Assert.Contains("MCP", content, StringComparison.OrdinalIgnoreCase); + + Console.WriteLine("[PLAYWRIGHT] Expected elements found"); + } + finally + { + await page.CloseAsync(); + await context.CloseAsync(); + } + } + + [Fact] + public async Task GradioLandingPage_Tabs_ShouldBeInteractive() + { + var context = await _playwrightFixture.Browser!.NewContextAsync(); + var page = await context.NewPageAsync(); + + try + { + await page.GotoAsync( + _fixture.GradioUrl, + new PageGotoOptions { WaitUntil = WaitUntilState.Load, Timeout = 30000 } + ); + + // Wait for Gradio to fully load + await page.WaitForLoadStateAsync(LoadState.DOMContentLoaded); + + // Give Gradio extra time to initialize its interactive elements + await Task.Delay(2000); + + // Look for tab navigation elements (Gradio uses specific classes) + var tabButtons = await page.QuerySelectorAllAsync("button[role='tab']"); + Console.WriteLine($"[PLAYWRIGHT] Found {tabButtons.Count} tab buttons"); + + // Verify tabs exist (Gradio typically has multiple tabs) + Assert.True(tabButtons.Count > 0, "Expected to find tab buttons in the UI"); + + Console.WriteLine("[PLAYWRIGHT] Tabs are present and interactive"); + } + finally + { + await page.CloseAsync(); + await context.CloseAsync(); + } + } + + [Fact] + public async Task GradioLandingPage_Assets_ShouldLoad() + { + var context = await _playwrightFixture.Browser!.NewContextAsync(); + var page = await context.NewPageAsync(); + + // Track failed requests + var failedRequests = new List(); + page.RequestFailed += (_, request) => + { + failedRequests.Add($"{request.Method} {request.Url} - {request.Failure}"); + Console.WriteLine($"[PLAYWRIGHT] Request failed: {request.Url}"); + }; + + try + { + await page.GotoAsync( + _fixture.GradioUrl, + new PageGotoOptions { WaitUntil = WaitUntilState.Load, Timeout = 30000 } + ); + + // Wait a bit for all assets to load + await Task.Delay(3000); + + // Check that we don't have critical failed requests + // Filter out expected 404s (like favicon.ico) + var criticalFailures = failedRequests + .Where(f => !f.Contains("favicon.ico") && !f.Contains("robots.txt")) + .ToList(); + + Console.WriteLine($"[PLAYWRIGHT] Total failed requests: {failedRequests.Count}"); + Console.WriteLine($"[PLAYWRIGHT] Critical failures: {criticalFailures.Count}"); + + if (criticalFailures.Any()) + { + Console.WriteLine("[PLAYWRIGHT] Critical failures:"); + foreach (var failure in criticalFailures) + { + Console.WriteLine($" - {failure}"); + } + } + + // Assert that critical assets loaded (some 404s for non-critical resources are acceptable) + Assert.True( + criticalFailures.Count < 5, + $"Too many critical asset failures: {string.Join(", ", criticalFailures)}" + ); + } + finally + { + await page.CloseAsync(); + await context.CloseAsync(); + } + } + + [Fact] + public async Task GradioLandingPage_Console_ShouldNotHave_CriticalErrors() + { + var context = await _playwrightFixture.Browser!.NewContextAsync(); + var page = await context.NewPageAsync(); + + var consoleErrors = new List(); + page.Console += (_, msg) => + { + if (msg.Type == "error") + { + consoleErrors.Add(msg.Text); + Console.WriteLine($"[PLAYWRIGHT] Console error: {msg.Text}"); + } + }; + + try + { + await page.GotoAsync( + _fixture.GradioUrl, + new PageGotoOptions { WaitUntil = WaitUntilState.Load, Timeout = 30000 } + ); + + // Wait for page to fully initialize + await Task.Delay(3000); + + Console.WriteLine($"[PLAYWRIGHT] Console errors count: {consoleErrors.Count}"); + + // Filter out non-critical errors (Gradio might have some warnings) + var criticalErrors = consoleErrors + .Where(e => + !e.Contains("favicon") && !e.Contains("Warning") && !e.Contains("DevTools") + ) + .ToList(); + + if (criticalErrors.Any()) + { + Console.WriteLine("[PLAYWRIGHT] Critical console errors:"); + foreach (var error in criticalErrors) + { + Console.WriteLine($" - {error}"); + } + } + + // Some console errors might be acceptable, but not too many + Assert.True( + criticalErrors.Count < 3, + $"Too many critical console errors: {string.Join(", ", criticalErrors)}" + ); + } + finally + { + await page.CloseAsync(); + await context.CloseAsync(); + } + } +} diff --git a/tests/RoslynStone.GradioTests/GradioLandingPageTests.cs b/tests/RoslynStone.GradioTests/GradioLandingPageTests.cs new file mode 100644 index 0000000000000000000000000000000000000000..00416aa42e78309ed27c46476734a0f32229faa6 --- /dev/null +++ b/tests/RoslynStone.GradioTests/GradioLandingPageTests.cs @@ -0,0 +1,88 @@ +namespace RoslynStone.GradioTests; + +/// +/// Smoke tests for Gradio landing page functionality. +/// Uses HttpClient instead of Playwright due to NewPageAsync() deadlock issues in containers. +/// +[Collection("McpServer")] +[Trait("Category", "Integration")] +[Trait("Component", "Gradio")] +public class GradioLandingPageTests : IAsyncLifetime +{ + private readonly McpServerFixture _fixture; + private HttpClient? _httpClient; + + public GradioLandingPageTests(McpServerFixture fixture) + { + _fixture = fixture; + } + + public Task InitializeAsync() + { + _httpClient = new HttpClient { Timeout = TimeSpan.FromSeconds(30) }; + Console.WriteLine("[TEST INIT] HttpClient initialized"); + return Task.CompletedTask; + } + + public Task DisposeAsync() + { + _httpClient?.Dispose(); + return Task.CompletedTask; + } + + [Fact] + public async Task GradioLandingPage_ShouldLoad_Successfully() + { + Console.WriteLine($"[TEST] Fetching {_fixture.GradioUrl}"); + + var response = await _httpClient!.GetAsync(_fixture.GradioUrl); + Console.WriteLine($"[TEST] Response status: {response.StatusCode}"); + + Assert.True(response.IsSuccessStatusCode, $"Expected 200, got {response.StatusCode}"); + + var content = await response.Content.ReadAsStringAsync(); + Console.WriteLine($"[TEST] Content length: {content.Length} bytes"); + + Assert.True(content.Length > 10000, $"Page content too small: {content.Length} bytes"); + Assert.Contains("gradio-app", content, StringComparison.OrdinalIgnoreCase); + Assert.Contains("Roslyn", content, StringComparison.OrdinalIgnoreCase); + + Console.WriteLine("[TEST] Page loaded successfully with expected content"); + } + + [Fact] + public async Task GradioLandingPage_ShouldContain_ExpectedElements() + { + var response = await _httpClient!.GetAsync(_fixture.GradioUrl); + var html = await response.Content.ReadAsStringAsync(); + + // Check for Gradio-specific elements + Assert.Contains("gradio-app", html); + Assert.Contains("", html, StringComparison.OrdinalIgnoreCase); + + // Check for assets/scripts + Assert.Contains(" +/// xUnit collection definition for sharing McpServerFixture across all Gradio tests. +/// This ensures the MCP server starts once and is reused for all tests in the collection. +/// +[CollectionDefinition("McpServer")] +public class McpServerCollection : ICollectionFixture +{ + // This class has no code, and is never instantiated. + // Its purpose is to be the place to apply [CollectionDefinition] and the fixtures. +} diff --git a/tests/RoslynStone.GradioTests/McpServerFixture.cs b/tests/RoslynStone.GradioTests/McpServerFixture.cs new file mode 100644 index 0000000000000000000000000000000000000000..ead55a8d838a7615e066220104413ec1167d7435 --- /dev/null +++ b/tests/RoslynStone.GradioTests/McpServerFixture.cs @@ -0,0 +1,250 @@ +using System.Diagnostics; +using System.Net; +// ReSharper disable once RedundantUsingDirective - Required for type resolution +using System.Net.Http; +using System.Net.Sockets; + +namespace RoslynStone.GradioTests; + +/// +/// Shared fixture that starts the MCP server in HTTP mode with Gradio landing page. +/// Ensures Python dependencies are installed via UV at runtime for test isolation. +/// +public sealed class McpServerFixture : IAsyncLifetime +{ + private Process? _serverProcess; + + /// + /// Base URL of the running MCP server (e.g., http://localhost:5000) + /// + public string BaseUrl { get; private set; } = string.Empty; + + /// + /// MCP endpoint URL (BaseUrl + /mcp) + /// + public string McpEndpoint => $"{BaseUrl}/mcp"; + + /// + /// Root URL (Gradio landing page) + /// + public string GradioUrl => BaseUrl; + + async Task IAsyncLifetime.InitializeAsync() + { + // Find a free port for the test server + var port = FindFreePort(); + BaseUrl = $"http://127.0.0.1:{port}"; + + // Determine if we're in CI or using pre-built assemblies + var configuration = Environment.GetEnvironmentVariable("Configuration") ?? "Debug"; + var skipPythonInstall = Environment.GetEnvironmentVariable("SKIP_PYTHON_INSTALL") == "true"; + + // Path to the built API assembly and its directory (contains pyproject.toml and will contain .venv) + var apiOutputDir = Path.GetFullPath( + Path.Combine( + AppContext.BaseDirectory, + $"../../../../../src/RoslynStone.Api/bin/{configuration}/net10.0" + ) + ); + var apiAssemblyPath = Path.Combine(apiOutputDir, "RoslynStone.Api.dll"); + var venvPath = Path.Combine(apiOutputDir, ".venv"); + var pyprojectPath = Path.Combine(apiOutputDir, "pyproject.toml"); + + // If not skipping Python install, ensure venv exists and install dependencies with UV + if (!skipPythonInstall) + { + Console.WriteLine($"[FIXTURE] Setting up Python environment in {apiOutputDir}"); + + // Create venv if it doesn't exist using UV (faster and compatible with UV pip) + if (!Directory.Exists(venvPath)) + { + Console.WriteLine($"[FIXTURE] Creating virtual environment at {venvPath} with UV"); + var createVenvProcess = Process.Start( + new ProcessStartInfo + { + FileName = "uv", + Arguments = $"venv \"{venvPath}\" --python python3.12", + UseShellExecute = false, + RedirectStandardOutput = true, + RedirectStandardError = true, + WorkingDirectory = apiOutputDir, + } + ); + await createVenvProcess!.WaitForExitAsync(); + + if (createVenvProcess.ExitCode != 0) + { + var error = await createVenvProcess.StandardError.ReadToEndAsync(); + Console.WriteLine($"[FIXTURE] Warning: Failed to create venv with UV: {error}"); + Console.WriteLine( + "[FIXTURE] Continuing - CSnakes will handle Python environment" + ); + } + } + + // Install dependencies with UV + if (File.Exists(pyprojectPath) && Directory.Exists(venvPath)) + { + Console.WriteLine( + $"[FIXTURE] Installing Python dependencies with UV from {pyprojectPath}" + ); + var uvProcess = Process.Start( + new ProcessStartInfo + { + FileName = "uv", + Arguments = + $"pip install --python \"{venvPath}/bin/python\" --prerelease=allow gradio>=6.0.0 httpx>=0.27.0 pygments>=2.17.0 openai>=1.0.0 anthropic>=0.25.0 google-generativeai>=0.3.0 huggingface_hub>=0.20.0", + UseShellExecute = false, + RedirectStandardOutput = true, + RedirectStandardError = true, + WorkingDirectory = apiOutputDir, + } + ); + + if (uvProcess != null) + { + uvProcess.OutputDataReceived += (_, e) => + { + if (!string.IsNullOrEmpty(e.Data)) + Console.WriteLine($"[UV] {e.Data}"); + }; + uvProcess.ErrorDataReceived += (_, e) => + { + if (!string.IsNullOrEmpty(e.Data)) + Console.WriteLine($"[UV] {e.Data}"); + }; + uvProcess.BeginOutputReadLine(); + uvProcess.BeginErrorReadLine(); + + await uvProcess.WaitForExitAsync(); + + if (uvProcess.ExitCode != 0) + { + Console.WriteLine( + "[FIXTURE] UV installation had issues, but continuing (CSnakes may install at runtime)" + ); + } + else + { + Console.WriteLine("[FIXTURE] Python dependencies installed successfully"); + } + } + } + } + + // Configure environment for HTTP transport + var startInfo = new ProcessStartInfo + { + FileName = "dotnet", + Arguments = $"exec \"{apiAssemblyPath}\"", + UseShellExecute = false, + RedirectStandardOutput = true, + RedirectStandardError = true, + CreateNoWindow = true, + WorkingDirectory = apiOutputDir, + }; + + // Set environment variables for HTTP mode + startInfo.Environment["MCP_TRANSPORT"] = "http"; + startInfo.Environment["ASPNETCORE_URLS"] = BaseUrl; + // Let CSnakes handle UV installation if we didn't pre-install + startInfo.Environment["SKIP_PYTHON_INSTALL"] = "false"; + startInfo.Environment["UV_PRERELEASE"] = "allow"; + startInfo.Environment["DOTNET_ENVIRONMENT"] = "Development"; + + _serverProcess = Process.Start(startInfo); + + if (_serverProcess == null) + { + throw new InvalidOperationException("Failed to start MCP server process"); + } + + // Capture output for debugging + _serverProcess.OutputDataReceived += (_, e) => + { + if (!string.IsNullOrEmpty(e.Data)) + { + Console.WriteLine($"[SERVER] {e.Data}"); + } + }; + _serverProcess.ErrorDataReceived += (_, e) => + { + if (!string.IsNullOrEmpty(e.Data)) + { + Console.Error.WriteLine($"[SERVER ERROR] {e.Data}"); + } + }; + _serverProcess.BeginOutputReadLine(); + _serverProcess.BeginErrorReadLine(); + + // Give server time to start and Gradio to initialize + // Allow extra time for CSnakes/UV installation if needed + var startupDelay = TimeSpan.FromSeconds(20); + await Task.Delay(startupDelay); + + // Verify server is responding + using var httpClient = new HttpClient(); + httpClient.Timeout = TimeSpan.FromSeconds(5); + var maxRetries = 10; + var retry = 0; + while (retry < maxRetries) + { + try + { + var response = await httpClient.GetAsync(BaseUrl); + if (response.IsSuccessStatusCode || response.StatusCode == HttpStatusCode.NotFound) + { + Console.WriteLine($"[FIXTURE] Server is responding at {BaseUrl}"); + break; + } + } + catch (Exception ex) + { + Console.WriteLine( + $"[FIXTURE] Waiting for server (attempt {retry + 1}/{maxRetries}): {ex.Message}" + ); + } + + retry++; + await Task.Delay(1000); + } + + if (retry >= maxRetries) + { + throw new TimeoutException( + $"Server at {BaseUrl} did not respond after {maxRetries} attempts" + ); + } + } + + Task IAsyncLifetime.DisposeAsync() + { + if (_serverProcess != null && !_serverProcess.HasExited) + { + try + { + _serverProcess.Kill(true); + _serverProcess.WaitForExit(5000); + } + catch + { + // Ignore errors during cleanup + } + finally + { + _serverProcess.Dispose(); + } + } + + return Task.CompletedTask; + } + + private static int FindFreePort() + { + using var socket = new TcpListener(IPAddress.Loopback, 0); + socket.Start(); + var port = ((IPEndPoint)socket.LocalEndpoint).Port; + socket.Stop(); + return port; + } +} diff --git a/tests/RoslynStone.GradioTests/PlaywrightCollection.cs b/tests/RoslynStone.GradioTests/PlaywrightCollection.cs new file mode 100644 index 0000000000000000000000000000000000000000..7d434a35719c7da8b3daa3778c39e60664aec1a4 --- /dev/null +++ b/tests/RoslynStone.GradioTests/PlaywrightCollection.cs @@ -0,0 +1,16 @@ +namespace RoslynStone.GradioTests; + +/// +/// xUnit collection definition for Playwright tests. +/// This collection uses both McpServerFixture (for the running server) +/// and PlaywrightFixture (for the browser instance). +/// Separated from HttpClient-only tests to avoid blocking if Playwright setup fails. +/// +[CollectionDefinition("Playwright")] +public class PlaywrightCollection + : ICollectionFixture, + ICollectionFixture +{ + // This class has no code, and is never instantiated. + // Its purpose is to be the place to apply [CollectionDefinition] and the fixtures. +} diff --git a/tests/RoslynStone.GradioTests/PlaywrightFixture.cs b/tests/RoslynStone.GradioTests/PlaywrightFixture.cs new file mode 100644 index 0000000000000000000000000000000000000000..554a0f23e3f052c6edab9c288599ec9e145e9f89 --- /dev/null +++ b/tests/RoslynStone.GradioTests/PlaywrightFixture.cs @@ -0,0 +1,83 @@ +using Microsoft.Playwright; + +namespace RoslynStone.GradioTests; + +/// +/// Shared fixture for Playwright browser instance. +/// Initializes browser once and reuses it across all Playwright tests. +/// Separate from McpServerFixture to avoid blocking HttpClient-only tests. +/// +public sealed class PlaywrightFixture : IAsyncLifetime +{ + private IPlaywright? _playwright; + + /// + /// The browser instance shared across all tests in the collection + /// + public IBrowser? Browser { get; private set; } + + async Task IAsyncLifetime.InitializeAsync() + { + try + { + Console.WriteLine("[PLAYWRIGHT FIXTURE] Initializing Playwright..."); + + // Initialize Playwright + _playwright = await Playwright.CreateAsync(); + + Console.WriteLine("[PLAYWRIGHT FIXTURE] Launching browser..."); + + // Launch browser with container-friendly settings + Browser = await _playwright.Chromium.LaunchAsync( + new BrowserTypeLaunchOptions + { + Headless = true, + Args = new[] + { + "--no-sandbox", + "--disable-setuid-sandbox", + "--disable-dev-shm-usage", + "--disable-gpu", + "--disable-software-rasterizer", + "--disable-extensions", + "--disable-background-networking", + "--disable-sync", + "--no-first-run", + "--no-default-browser-check", + }, + Timeout = 60000, // 60 second timeout for browser launch + } + ); + + Console.WriteLine("[PLAYWRIGHT FIXTURE] Browser initialized successfully"); + } + catch (Exception ex) + { + Console.WriteLine($"[PLAYWRIGHT FIXTURE] Failed to initialize: {ex.Message}"); + Console.WriteLine($"[PLAYWRIGHT FIXTURE] Stack trace: {ex.StackTrace}"); + throw; + } + } + + async Task IAsyncLifetime.DisposeAsync() + { + Console.WriteLine("[PLAYWRIGHT FIXTURE] Cleaning up..."); + + if (Browser != null) + { + try + { + await Browser.CloseAsync(); + await Browser.DisposeAsync(); + Console.WriteLine("[PLAYWRIGHT FIXTURE] Browser closed"); + } + catch (Exception ex) + { + Console.WriteLine($"[PLAYWRIGHT FIXTURE] Error closing browser: {ex.Message}"); + } + } + + _playwright?.Dispose(); + Console.WriteLine("[PLAYWRIGHT FIXTURE] Cleanup complete"); + } +} diff --git a/tests/RoslynStone.GradioTests/RoslynStone.GradioTests.csproj b/tests/RoslynStone.GradioTests/RoslynStone.GradioTests.csproj new file mode 100644 index 0000000000000000000000000000000000000000..282688c4dd6489cbf3cd73fb67c6045be4a2efa2 --- /dev/null +++ b/tests/RoslynStone.GradioTests/RoslynStone.GradioTests.csproj @@ -0,0 +1,33 @@ + + + net10.0 + 14 + enable + enable + false + true + + + + + + + + + + + + + + + + + + PreserveNewest + + + + + + + diff --git a/tests/RoslynStone.GradioTests/xunit.runner.json b/tests/RoslynStone.GradioTests/xunit.runner.json new file mode 100644 index 0000000000000000000000000000000000000000..953eedb4315e06c2929ad7061ff88519307a5c04 --- /dev/null +++ b/tests/RoslynStone.GradioTests/xunit.runner.json @@ -0,0 +1,4 @@ +{ + "parallelizeTestCollections": false, + "maxParallelThreads": 1 +} diff --git a/tests/RoslynStone.LoadTests/Program.cs b/tests/RoslynStone.LoadTests/Program.cs new file mode 100644 index 0000000000000000000000000000000000000000..198f32b9f2f5cb74fec4ef23f89916381d3ec57f --- /dev/null +++ b/tests/RoslynStone.LoadTests/Program.cs @@ -0,0 +1,365 @@ +using System.Diagnostics; +using System.Text; +using System.Text.Json; +using RoslynStone.LoadTests.Serialization; + +namespace RoslynStone.LoadTests; + +public class Program +{ + private const int DefaultConcurrency = 300; + private const int DefaultRounds = 10; + private const string DefaultBaseUrl = "http://localhost:7071"; + + public static async Task Main(string[] args) + { + // Parse command line arguments + var baseUrl = args.Length > 0 ? args[0] : DefaultBaseUrl; + var concurrency = args.Length > 1 ? int.Parse(args[1]) : DefaultConcurrency; + var rounds = args.Length > 2 ? int.Parse(args[2]) : DefaultRounds; + + Console.WriteLine("╔═══════════════════════════════════════════════════════╗"); + Console.WriteLine("║ Roslyn-Stone MCP Server Load Test ║"); + Console.WriteLine("╚═══════════════════════════════════════════════════════╝"); + Console.WriteLine(); + Console.WriteLine($"Configuration:"); + Console.WriteLine($" Base URL: {baseUrl}"); + Console.WriteLine($" Concurrency: {concurrency}"); + Console.WriteLine($" Rounds: {rounds}"); + Console.WriteLine(); + + // Check if server is available + Console.WriteLine("Checking server availability..."); + // ReSharper disable once UseObjectOrCollectionInitializer - HttpClient initialization is safe + using var client = new HttpClient + { + BaseAddress = new Uri(baseUrl), + Timeout = TimeSpan.FromSeconds(30), + }; + + try + { + var healthCheck = await client.GetAsync("/health"); + if (!healthCheck.IsSuccessStatusCode) + { + Console.WriteLine($"⚠️ Server health check returned {healthCheck.StatusCode}"); + } + else + { + Console.WriteLine("✅ Server is available"); + } + } + catch (Exception ex) + { + Console.WriteLine($"❌ Server is not available: {ex.Message}"); + Console.WriteLine("\nPlease start the server with:"); + Console.WriteLine(" cd src/RoslynStone.Api"); + Console.WriteLine(" MCP_TRANSPORT=http dotnet run"); + return; + } + + Console.WriteLine(); + Console.WriteLine("Starting load test..."); + Console.WriteLine(); + + var loadTester = new LoadTester(client, concurrency, rounds); + var results = await loadTester.RunAsync(); + + Console.WriteLine(); + Console.WriteLine("╔═══════════════════════════════════════════════════════╗"); + Console.WriteLine("║ Test Results ║"); + Console.WriteLine("╚═══════════════════════════════════════════════════════╝"); + Console.WriteLine(); + + results.PrintSummary(); + } +} + +public class LoadTester +{ + private readonly HttpClient _client; + private readonly int _concurrency; + private readonly int _rounds; + + public LoadTester(HttpClient client, int concurrency, int rounds) + { + _client = client; + _concurrency = concurrency; + _rounds = rounds; + } + + public async Task RunAsync() + { + var results = new LoadTestResults(_concurrency, _rounds); + + // Test scenarios + var scenarios = new[] + { + ("Simple Expression", CreateSimpleExpressionRequest()), + ("Variable Assignment", CreateVariableAssignmentRequest()), + ("LINQ Query", CreateLinqQueryRequest()), + ("Context Management", CreateContextManagementRequest()), + }; + + foreach (var (scenarioName, requestContent) in scenarios) + { + Console.WriteLine($"Testing scenario: {scenarioName}"); + var scenarioResults = await RunScenarioAsync(requestContent); + results.AddScenario(scenarioName, scenarioResults); + Console.WriteLine($" ✅ Completed"); + } + + return results; + } + + private async Task RunScenarioAsync(string requestContent) + { + var scenarioResults = new ScenarioResults(_rounds); + + for (int round = 0; round < _rounds; round++) + { + var sw = Stopwatch.StartNew(); + var tasks = new List>(); + + for (int i = 0; i < _concurrency; i++) + { + tasks.Add(ExecuteRequestAsync(requestContent)); + } + + var roundResults = await Task.WhenAll(tasks); + sw.Stop(); + + var successCount = roundResults.Count(r => r.Success); + var failureCount = roundResults.Count(r => !r.Success); + var avgResponseTime = roundResults + .Where(r => r.Success) + .Select(r => r.ResponseTimeMs) + .DefaultIfEmpty(0) + .Average(); + + scenarioResults.AddRound( + round, + sw.ElapsedMilliseconds, + successCount, + failureCount, + avgResponseTime + ); + } + + return scenarioResults; + } + + private async Task ExecuteRequestAsync(string requestContent) + { + var sw = Stopwatch.StartNew(); + try + { + using var content = new StringContent( + requestContent, + Encoding.UTF8, + "application/json" + ); + var response = await _client.PostAsync("/mcp", content); + sw.Stop(); + + return new RoundResult + { + Success = response.IsSuccessStatusCode, + ResponseTimeMs = sw.ElapsedMilliseconds, + StatusCode = (int)response.StatusCode, + }; + } + catch (Exception ex) + { + sw.Stop(); + return new RoundResult + { + Success = false, + ResponseTimeMs = sw.ElapsedMilliseconds, + Error = ex.Message, + }; + } + } + + private static string CreateSimpleExpressionRequest() + { + var request = new + { + jsonrpc = "2.0", + method = "tools/call", + @params = new { name = "EvaluateCsharp", arguments = new { code = "2 + 2" } }, + id = 1, + }; + return JsonSerializer.Serialize(request, LoadTestJsonContext.Default.Object); + } + + private static string CreateVariableAssignmentRequest() + { + var request = new + { + jsonrpc = "2.0", + method = "tools/call", + @params = new + { + name = "EvaluateCsharp", + arguments = new { code = "var x = 10; x * 2" }, + }, + id = 1, + }; + return JsonSerializer.Serialize(request, LoadTestJsonContext.Default.Object); + } + + private static string CreateLinqQueryRequest() + { + var request = new + { + jsonrpc = "2.0", + method = "tools/call", + @params = new + { + name = "EvaluateCsharp", + arguments = new { code = "Enumerable.Range(1, 100).Where(x => x % 2 == 0).Sum()" }, + }, + id = 1, + }; + return JsonSerializer.Serialize(request, LoadTestJsonContext.Default.Object); + } + + private static string CreateContextManagementRequest() + { + var request = new + { + jsonrpc = "2.0", + method = "tools/call", + @params = new + { + name = "EvaluateCsharp", + arguments = new { code = "int counter = 0; counter++; counter" }, + }, + id = 1, + }; + return JsonSerializer.Serialize(request, LoadTestJsonContext.Default.Object); + } +} + +public record RoundResult +{ + public bool Success { get; init; } + public long ResponseTimeMs { get; init; } + + // ReSharper disable once UnusedAutoPropertyAccessor.Global - Part of result contract + public int StatusCode { get; init; } + + // ReSharper disable once UnusedAutoPropertyAccessor.Global - Part of result contract + public string? Error { get; init; } +} + +public class ScenarioResults +{ + private readonly List<( + int Round, + long TotalMs, + int Success, + int Failures, + double AvgResponseMs + )> _rounds = new(); + + // ReSharper disable once NotAccessedField.Local - Reserved for future validation logic + private readonly int _expectedRounds; + + public ScenarioResults(int expectedRounds) + { + _expectedRounds = expectedRounds; + } + + public void AddRound( + int round, + long totalMs, + int successCount, + int failureCount, + double avgResponseMs + ) + { + _rounds.Add((round, totalMs, successCount, failureCount, avgResponseMs)); + } + + public double AverageTotalTimeMs => _rounds.Average(r => r.TotalMs); + public double AverageResponseTimeMs => _rounds.Average(r => r.AvgResponseMs); + public int TotalSuccess => _rounds.Sum(r => r.Success); + public int TotalFailures => _rounds.Sum(r => r.Failures); + public double SuccessRate => TotalSuccess / (double)(TotalSuccess + TotalFailures) * 100; + + public IReadOnlyList<( + int Round, + long TotalMs, + int Success, + int Failures, + double AvgResponseMs + )> Rounds => _rounds; +} + +public class LoadTestResults +{ + private readonly Dictionary _scenarios = new(); + private readonly int _concurrency; + private readonly int _rounds; + + public LoadTestResults(int concurrency, int rounds) + { + _concurrency = concurrency; + _rounds = rounds; + } + + public void AddScenario(string name, ScenarioResults results) + { + _scenarios[name] = results; + } + + public void PrintSummary() + { + Console.WriteLine($"Overall Statistics:"); + Console.WriteLine($" Concurrency: {_concurrency} requests/round"); + Console.WriteLine($" Rounds: {_rounds}"); + Console.WriteLine($" Total Requests: {_concurrency * _rounds * _scenarios.Count}"); + Console.WriteLine(); + + foreach (var (scenarioName, results) in _scenarios) + { + Console.WriteLine($"Scenario: {scenarioName}"); + Console.WriteLine($" Average Round Time: {results.AverageTotalTimeMs:F2} ms"); + Console.WriteLine($" Average Response Time: {results.AverageResponseTimeMs:F2} ms"); + Console.WriteLine($" Success Rate: {results.SuccessRate:F2}%"); + Console.WriteLine( + $" Total Success: {results.TotalSuccess}/{results.TotalSuccess + results.TotalFailures}" + ); + + if (results.TotalFailures > 0) + { + Console.WriteLine($" ⚠️ Total Failures: {results.TotalFailures}"); + } + + // Calculate requests per second + var rps = _concurrency / (results.AverageTotalTimeMs / 1000.0); + Console.WriteLine($" Throughput: {rps:F2} requests/second"); + Console.WriteLine(); + } + + // Overall success rate + var totalSuccess = _scenarios.Values.Sum(r => r.TotalSuccess); + var totalRequests = _scenarios.Values.Sum(r => r.TotalSuccess + r.TotalFailures); + var overallSuccessRate = totalSuccess / (double)totalRequests * 100; + + Console.WriteLine($"Overall Success Rate: {overallSuccessRate:F2}%"); + + if (overallSuccessRate < 99.0) + { + Console.WriteLine( + "⚠️ Warning: Success rate is below 99%. Check server logs for errors." + ); + } + else + { + Console.WriteLine("✅ All tests passed with high success rate!"); + } + } +} diff --git a/tests/RoslynStone.LoadTests/README.md b/tests/RoslynStone.LoadTests/README.md new file mode 100644 index 0000000000000000000000000000000000000000..66b11a4a7da8299b30406965beadaf860df2f304 --- /dev/null +++ b/tests/RoslynStone.LoadTests/README.md @@ -0,0 +1,125 @@ +# Roslyn-Stone Load Tests + +This project contains load tests for the Roslyn-Stone MCP server HTTP transport. + +## Overview + +The load tests simulate concurrent requests to the MCP server to ensure it can handle multiple simultaneous clients. Tests include: +- Simple expression evaluation +- Variable assignment +- LINQ queries +- NuGet package search + +## Prerequisites + +The load test requires the RoslynStone.Api server to be running in HTTP mode. + +### Start the Server + +```bash +cd src/RoslynStone.Api +MCP_TRANSPORT=http dotnet run +``` + +The server will start on `http://localhost:7071` by default. + +## Running Load Tests + +### Using .NET CLI + +```bash +dotnet run --project tests/RoslynStone.LoadTests +``` + +### Custom Configuration + +```bash +# Custom base URL, concurrency, and rounds +dotnet run --project tests/RoslynStone.LoadTests -- http://localhost:8080 500 20 +``` + +Arguments: +1. Base URL (default: `http://localhost:7071`) +2. Concurrency (default: `300` requests per round) +3. Rounds (default: `10`) + +### Using Cake Build Script + +```bash +dotnet cake --target=Load-Test +``` + +## Test Configuration + +Default settings: +- **Concurrency**: 300 concurrent requests per round +- **Rounds**: 10 rounds per scenario +- **Total Requests**: 12,000 (300 × 10 × 4 scenarios) + +## Test Scenarios + +1. **Simple Expression** - `2 + 2` +2. **Variable Assignment** - `var x = 10; x * 2` +3. **LINQ Query** - `Enumerable.Range(1, 100).Where(x => x % 2 == 0).Sum()` +4. **NuGet Search** - Search for "Newtonsoft.Json" + +## Metrics Reported + +For each scenario: +- **Average Round Time** - Time to complete all concurrent requests +- **Average Response Time** - Per-request response time +- **Success Rate** - Percentage of successful requests +- **Throughput** - Requests per second +- **Total Success/Failures** - Count of successful and failed requests + +## Expected Results + +A healthy server should achieve: +- ✅ Success rate > 99% +- ✅ Average response time < 100ms for simple operations +- ✅ Throughput > 1000 requests/second + +## Troubleshooting + +### Server Not Available + +``` +❌ Server is not available: Connection refused +``` + +**Solution**: Start the server first: +```bash +cd src/RoslynStone.Api +MCP_TRANSPORT=http dotnet run +``` + +### High Failure Rate + +If you see a success rate below 99%: +1. Check server logs for errors +2. Verify server has adequate resources +3. Reduce concurrency level +4. Check network connectivity + +### Timeout Errors + +If requests are timing out: +1. Increase the timeout in `Program.cs` +2. Check server performance +3. Reduce concurrency level + +## Performance Tuning + +To optimize server performance: +1. Run in Release configuration +2. Use production-ready hosting (Kestrel optimizations) +3. Enable response compression +4. Configure appropriate thread pool sizes +5. Monitor memory usage and GC pressure + +## CI Integration + +Load tests are optional in CI and can be run manually: +- They require a running server instance +- Results should be monitored for performance regressions +- Consider using dedicated load testing infrastructure diff --git a/tests/RoslynStone.LoadTests/RoslynStone.LoadTests.csproj b/tests/RoslynStone.LoadTests/RoslynStone.LoadTests.csproj new file mode 100644 index 0000000000000000000000000000000000000000..8be31084949cd0676785ba8533545f460308e3d6 --- /dev/null +++ b/tests/RoslynStone.LoadTests/RoslynStone.LoadTests.csproj @@ -0,0 +1,15 @@ + + + Exe + net10.0 + 14 + enable + enable + false + true + + + + + + diff --git a/tests/RoslynStone.LoadTests/Serialization/LoadTestJsonContext.cs b/tests/RoslynStone.LoadTests/Serialization/LoadTestJsonContext.cs new file mode 100644 index 0000000000000000000000000000000000000000..ad7cf519d9d301d4895c3cc4fe2d2153ba40ccb5 --- /dev/null +++ b/tests/RoslynStone.LoadTests/Serialization/LoadTestJsonContext.cs @@ -0,0 +1,17 @@ +using System.Text.Json.Serialization; + +namespace RoslynStone.LoadTests.Serialization; + +/// +/// Source-generated JSON serialization context for load tests +/// Provides high-performance JSON serialization for MCP requests +/// +[JsonSourceGenerationOptions( + WriteIndented = false, + PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase, + DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull, + GenerationMode = JsonSourceGenerationMode.Default +)] +[JsonSerializable(typeof(object))] +[JsonSerializable(typeof(Dictionary))] +public partial class LoadTestJsonContext : JsonSerializerContext; diff --git a/tests/RoslynStone.Tests/AssemblyExecutionServiceTests.cs b/tests/RoslynStone.Tests/AssemblyExecutionServiceTests.cs new file mode 100644 index 0000000000000000000000000000000000000000..e8afdc8d4c17e8a763a33403bfccb4b6523b2b3e --- /dev/null +++ b/tests/RoslynStone.Tests/AssemblyExecutionServiceTests.cs @@ -0,0 +1,227 @@ +using RoslynStone.Infrastructure.Services; + +namespace RoslynStone.Tests; + +/// +/// Tests for AssemblyExecutionService - verifies dynamic assembly execution with proper unloading +/// Based on best practices from Laurent Kempé's approach +/// +[Trait("Category", "Integration")] +[Trait("Component", "Execution")] +public class AssemblyExecutionServiceTests +{ + [Fact] + [Trait("Feature", "Execution")] + public async Task ExecuteCodeAsync_SimpleProgram_Succeeds() + { + // Arrange + var compilationService = new CompilationService(); + var executionService = new AssemblyExecutionService(compilationService); + var code = + @" +using System; + +public class Program +{ + public static void Main() + { + Console.WriteLine(""Hello, World!""); + } +}"; + + // Act + var result = await executionService.ExecuteCodeAsync(code); + + // Assert + Assert.True(result.Success, result.ErrorMessage ?? "No error message"); + Assert.NotNull(result.Output); + Assert.Contains("Hello, World!", result.Output); + } + + [Fact] + [Trait("Feature", "Execution")] + public async Task ExecuteCodeAsync_TopLevelStatements_Succeeds() + { + // Arrange + var compilationService = new CompilationService(); + var executionService = new AssemblyExecutionService(compilationService); + var code = + @" +using System; +Console.WriteLine(""Top-level statement test""); +"; + + // Act + var result = await executionService.ExecuteCodeAsync(code); + + // Assert + Assert.True(result.Success, result.ErrorMessage ?? "No error message"); + Assert.Contains("Top-level statement test", result.Output); + } + + [Fact] + [Trait("Feature", "Execution")] + public async Task ExecuteCodeAsync_CompilationError_ReturnsError() + { + // Arrange + var compilationService = new CompilationService(); + var executionService = new AssemblyExecutionService(compilationService); + var code = "this is not valid C# code"; + + // Act + var result = await executionService.ExecuteCodeAsync(code); + + // Assert + Assert.False(result.Success); + Assert.NotNull(result.ErrorMessage); + Assert.Contains("Compilation failed", result.ErrorMessage); + Assert.NotNull(result.CompilationErrors); + } + + [Fact] + [Trait("Feature", "Execution")] + public async Task ExecuteCodeAsync_RuntimeException_CapturesError() + { + // Arrange + var compilationService = new CompilationService(); + var executionService = new AssemblyExecutionService(compilationService); + var code = + @" +using System; + +public class Program +{ + public static void Main() + { + throw new Exception(""Runtime error test""); + } +}"; + + // Act + var result = await executionService.ExecuteCodeAsync(code); + + // Assert + Assert.False(result.Success); + Assert.NotNull(result.ErrorMessage); + Assert.Contains("Execution error", result.ErrorMessage); + } + + [Fact(Skip = "Async output capture is environment-dependent")] + [Trait("Feature", "Execution")] + public async Task ExecuteCodeAsync_AsyncMain_HandlesAsyncExecution() + { + // Arrange + var compilationService = new CompilationService(); + var executionService = new AssemblyExecutionService(compilationService); + var code = + @" +using System; +using System.Threading.Tasks; + +public class Program +{ + public static async Task Main() + { + await Task.Delay(10); + Console.WriteLine(""Async execution completed""); + } +}"; + + // Act + var result = await executionService.ExecuteCodeAsync(code); + + // Assert + Assert.True(result.Success, result.ErrorMessage ?? "No error message"); + Assert.Contains("Async execution completed", result.Output); + } + + [Fact] + [Trait("Feature", "MemoryManagement")] + public async Task ExecuteCodeAsync_MultipleExecutions_DoesNotLeakMemory() + { + // Arrange + var compilationService = new CompilationService(); + var executionService = new AssemblyExecutionService(compilationService); + var code = + @" +using System; +public class Program +{ + public static void Main() + { + Console.WriteLine(""Test""); + } +}"; + + // Act - Execute multiple times to verify no memory leaks + for (int i = 0; i < 5; i++) + { + var result = await executionService.ExecuteCodeAsync(code); + Assert.True(result.Success); + } + + // Force garbage collection + GC.Collect(); + GC.WaitForPendingFinalizers(); + GC.Collect(); + + // Assert - If we get here without OOM, memory management is working + Assert.True(true); + } + + [Fact] + [Trait("Feature", "Execution")] + public async Task ExecuteFileAsync_NonExistentFile_ReturnsError() + { + // Arrange + var compilationService = new CompilationService(); + var executionService = new AssemblyExecutionService(compilationService); + var filePath = "/tmp/nonexistent_file_12345.cs"; + + // Act + var result = await executionService.ExecuteFileAsync(filePath); + + // Assert + Assert.False(result.Success); + Assert.Contains("File not found", result.ErrorMessage); + } + + [Fact] + [Trait("Feature", "Execution")] + public async Task ExecuteFileAsync_ValidFile_Succeeds() + { + // Arrange + var compilationService = new CompilationService(); + var executionService = new AssemblyExecutionService(compilationService); + var filePath = Path.Combine(Path.GetTempPath(), $"test_{Guid.NewGuid()}.cs"); + var code = + @" +using System; +public class Program +{ + public static void Main() + { + Console.WriteLine(""File execution test""); + } +}"; + + try + { + await File.WriteAllTextAsync(filePath, code); + + // Act + var result = await executionService.ExecuteFileAsync(filePath); + + // Assert + Assert.True(result.Success, result.ErrorMessage ?? "No error message"); + Assert.Contains("File execution test", result.Output); + } + finally + { + if (File.Exists(filePath)) + { + File.Delete(filePath); + } + } + } +} diff --git a/tests/RoslynStone.Tests/CompilationServiceEdgeCasesTests.cs b/tests/RoslynStone.Tests/CompilationServiceEdgeCasesTests.cs new file mode 100644 index 0000000000000000000000000000000000000000..94333599cd70732e89a5b256db46ec54251a464e --- /dev/null +++ b/tests/RoslynStone.Tests/CompilationServiceEdgeCasesTests.cs @@ -0,0 +1,228 @@ +using Microsoft.CodeAnalysis; +using RoslynStone.Infrastructure.Services; + +namespace RoslynStone.Tests; + +/// +/// Edge case tests for CompilationService to improve branch coverage +/// +[Trait("Category", "Unit")] +[Trait("Component", "Compilation")] +public class CompilationServiceEdgeCasesTests +{ + [Fact] + [Trait("Feature", "Compilation")] + public void Compile_EmptyCode_FailsWithError() + { + // Arrange + var service = new CompilationService(); + var code = ""; + + // Act + var result = service.Compile(code); + + // Assert + Assert.False(result.Success); + Assert.NotNull(result.ErrorMessages); + } + + [Fact] + [Trait("Feature", "Compilation")] + public void Compile_OnlyWhitespace_FailsWithError() + { + // Arrange + var service = new CompilationService(); + var code = " \n\t "; + + // Act + var result = service.Compile(code); + + // Assert + Assert.False(result.Success); + } + + [Fact] + [Trait("Feature", "Compilation")] + public void Compile_MultipleErrors_ReturnsAllErrors() + { + // Arrange + var service = new CompilationService(); + var code = + @" +int x = ""string""; // Error 1 +int y = 'c'; // Error 2 - char to int +unknown type z; // Error 3 +"; + + // Act + var result = service.Compile(code); + + // Assert + Assert.False(result.Success); + Assert.NotNull(result.Diagnostics); + Assert.NotEmpty(result.Diagnostics); + Assert.True(result.Diagnostics.Count >= 2); + } + + [Fact] + [Trait("Feature", "Compilation")] + public void Compile_UnsafeCode_FailsWithError() + { + // Arrange + var service = new CompilationService(); + var code = + @" +unsafe +{ + int* p = null; +}"; + + // Act + var result = service.Compile(code); + + // Assert - Should fail because unsafe is not allowed + Assert.False(result.Success); + } + + [Fact] + [Trait("Feature", "Compilation")] + public void Compile_UnknownType_FailsWithError() + { + // Arrange + var service = new CompilationService(); + var code = "NonExistentType x = new NonExistentType();"; + + // Act + var result = service.Compile(code); + + // Assert + Assert.False(result.Success); + Assert.NotNull(result.Diagnostics); + Assert.Contains(result.Diagnostics, d => d.Id.StartsWith("CS")); + } + + [Fact] + [Trait("Feature", "Compilation")] + public void Compile_InvalidSyntax_FailsWithSpecificError() + { + // Arrange + var service = new CompilationService(); + var code = "if ( { }"; // Invalid syntax + + // Act + var result = service.Compile(code); + + // Assert + Assert.False(result.Success); + Assert.Contains(result.Diagnostics!, d => d.Severity == DiagnosticSeverity.Error); + } + + [Fact] + [Trait("Feature", "Compilation")] + public void Compile_MissingNamespace_FailsWithError() + { + // Arrange + var service = new CompilationService(); + var code = + @" +public class Program +{ + public static void Main() + { + HttpClient client = new HttpClient(); // Missing using System.Net.Http + } +}"; + + // Act + var result = service.Compile(code); + + // Assert + Assert.False(result.Success); + } + + [Fact] + [Trait("Feature", "Compilation")] + public void Compile_LargeCode_CompilesSuccessfully() + { + // Arrange + var service = new CompilationService(); + var codeBuilder = new System.Text.StringBuilder(); + codeBuilder.AppendLine("using System;"); + codeBuilder.AppendLine("public class Program {"); + codeBuilder.AppendLine("public static void Main() {"); + + // Add many statements to test compilation of larger code + for (int i = 0; i < 100; i++) + { + codeBuilder.AppendLine($" var x{i} = {i};"); + } + + codeBuilder.AppendLine("}}"); + var code = codeBuilder.ToString(); + + // Act + var result = service.Compile(code); + + // Assert + Assert.True(result.Success); + } + + [Fact] + [Trait("Feature", "AssemblyName")] + public void Compile_NullAssemblyName_GeneratesName() + { + // Arrange + var service = new CompilationService(); + var code = "public class Program { public static void Main() { } }"; + + // Act + // ReSharper disable once RedundantArgumentDefaultValue - Explicit for test clarity + var result = service.Compile(code, null); + + // Assert + Assert.True(result.Success); + Assert.NotNull(result.AssemblyName); + Assert.StartsWith("DynamicAssembly_", result.AssemblyName); + } + + [Fact] + [Trait("Feature", "OutputStreams")] + public void Compile_SuccessfulCompilation_HasBothStreams() + { + // Arrange + var service = new CompilationService(); + var code = "public class Program { public static void Main() { } }"; + + // Act + var result = service.Compile(code); + + // Assert + Assert.True(result.Success); + Assert.NotNull(result.AssemblyStream); + Assert.NotNull(result.SymbolsStream); + Assert.True(result.AssemblyStream.Length > 0); + Assert.True(result.SymbolsStream.Length > 0); + } + + [Fact] + [Trait("Feature", "ErrorMessages")] + public void Compile_ErrorWithLocation_IncludesLocationInMessage() + { + // Arrange + var service = new CompilationService(); + var code = + @" +using System; +int x = ""error""; +"; + + // Act + var result = service.Compile(code); + + // Assert + Assert.False(result.Success); + Assert.NotEmpty(result.ErrorMessages!); + // Error messages should include error codes + Assert.NotNull(result.ErrorMessages); + } +} diff --git a/tests/RoslynStone.Tests/CompilationServiceTests.cs b/tests/RoslynStone.Tests/CompilationServiceTests.cs new file mode 100644 index 0000000000000000000000000000000000000000..70ba8c72a0ef214f3282b9c865e3e8b700f05429 --- /dev/null +++ b/tests/RoslynStone.Tests/CompilationServiceTests.cs @@ -0,0 +1,149 @@ +using RoslynStone.Infrastructure.Services; + +namespace RoslynStone.Tests; + +/// +/// Tests for CompilationService - verifies Roslyn compilation functionality +/// +[Trait("Category", "Unit")] +[Trait("Component", "Compilation")] +public class CompilationServiceTests +{ + [Fact] + [Trait("Feature", "Compilation")] + public void Compile_SimpleCode_Succeeds() + { + // Arrange + var service = new CompilationService(); + var code = + @" +using System; + +public class Program +{ + public static void Main() + { + Console.WriteLine(""Hello, World!""); + } +}"; + + // Act + var result = service.Compile(code); + + // Assert + Assert.True( + result.Success, + $"Compilation failed: {string.Join(", ", result.ErrorMessages ?? new List())}" + ); + Assert.NotNull(result.AssemblyStream); + Assert.NotNull(result.AssemblyName); + Assert.True(result.AssemblyStream!.Length > 0); + } + + [Fact] + [Trait("Feature", "Compilation")] + public void Compile_TopLevelStatements_Succeeds() + { + // Arrange + var service = new CompilationService(); + var code = + @" +using System; +Console.WriteLine(""Hello from top-level!""); +"; + + // Act + var result = service.Compile(code); + + // Assert + Assert.True(result.Success); + Assert.NotNull(result.AssemblyStream); + } + + [Fact] + [Trait("Feature", "Compilation")] + public void Compile_InvalidCode_ReturnsErrors() + { + // Arrange + var service = new CompilationService(); + var code = "this is not valid C# code!!!"; + + // Act + var result = service.Compile(code); + + // Assert + Assert.False(result.Success); + Assert.NotNull(result.ErrorMessages); + Assert.NotEmpty(result.ErrorMessages); + Assert.NotNull(result.Diagnostics); + } + + [Fact] + [Trait("Feature", "Compilation")] + public void Compile_SyntaxError_ReturnsErrorWithLocation() + { + // Arrange + var service = new CompilationService(); + var code = + @" +using System; + +public class Program +{ + public static void Main() + { + int x = ""not a number""; // Type mismatch + } +}"; + + // Act + var result = service.Compile(code); + + // Assert + Assert.False(result.Success); + Assert.NotNull(result.Diagnostics); + Assert.NotEmpty(result.Diagnostics); + Assert.Contains(result.Diagnostics, d => d.Id == "CS0029" || d.Id.StartsWith("CS")); + } + + [Fact] + [Trait("Feature", "Compilation")] + public void Compile_MultipleCompilations_GeneratesUniqueNames() + { + // Arrange + var service = new CompilationService(); + var code = + @" +using System; +public class Program { public static void Main() { } }"; + + // Act + var result1 = service.Compile(code); + var result2 = service.Compile(code); + + // Assert + Assert.True(result1.Success); + Assert.True(result2.Success); + Assert.NotEqual(result1.AssemblyName, result2.AssemblyName); + } + + [Fact] + [Trait("Feature", "Compilation")] + public void Compile_CustomAssemblyName_UsesProvidedName() + { + // Arrange + var service = new CompilationService(); + var code = + @" +using System; +public class Program { public static void Main() { } }"; + var customName = "MyCustomAssembly"; + + // Act + var result = service.Compile(code, customName); + + // Assert + Assert.True(result.Success); + Assert.Equal(customName, result.AssemblyName); + } +} diff --git a/tests/RoslynStone.Tests/CriticalBugsTests.cs b/tests/RoslynStone.Tests/CriticalBugsTests.cs new file mode 100644 index 0000000000000000000000000000000000000000..f418b052041aa764adadf6785cfaeb065a839500 --- /dev/null +++ b/tests/RoslynStone.Tests/CriticalBugsTests.cs @@ -0,0 +1,357 @@ +using System.Text.Json; +using RoslynStone.Core.Models; +using RoslynStone.Infrastructure.Services; +using RoslynStone.Infrastructure.Tools; +using RoslynStone.Tests.Serialization; + +namespace RoslynStone.Tests; + +/// +/// Tests for critical bugs discovered in MCP audit +/// These tests should FAIL initially, then PASS after fixes are applied (TDD style) +/// +[Trait("Category", "Integration")] +[Trait("Component", "CriticalBugs")] +public class CriticalBugsTests : IDisposable +{ + private readonly RoslynScriptingService _scriptingService; + private readonly NuGetService _nugetService; + private readonly DocumentationService _documentationService; + private readonly IReplContextManager _contextManager; + + public CriticalBugsTests() + { + _scriptingService = new RoslynScriptingService(); + _nugetService = new NuGetService(); + _documentationService = new DocumentationService(_nugetService); + _contextManager = new ReplContextManager(); + } + + public void Dispose() + { + _nugetService.Dispose(); + } + + #region Package Loading in Context + + [Fact] + [Trait("Feature", "NuGetPackagesParameter")] + public async Task EvaluateCsharp_WithNugetPackagesParameter_SingleShot_ShouldWork() + { + // Test single-shot execution with packages (temporary isolated context) + // Context is created, used, and destroyed automatically + + // Arrange + var nugetPackages = new[] + { + new NuGetPackageSpec { PackageName = "Humanizer", Version = "3.0.1" }, + }; + + // Act - Single-shot execution (createContext=false, no contextId) + var result = await ReplTools.EvaluateCsharp( + _scriptingService, + _contextManager, + _nugetService, + @"using Humanizer; return ""test"".Humanize();", + nugetPackages: nugetPackages + ); + + // Assert - Should succeed + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + Assert.NotNull(resultDict); + Assert.True( + resultDict["success"].GetBoolean(), + "Package should be available in isolated context" + ); + Assert.Equal("Test", resultDict["returnValue"].GetString()); + + // Context should not be returned (it was temporary) + Assert.False( + resultDict.TryGetValue("contextId", out var contextIdElement) + && contextIdElement.ValueKind != JsonValueKind.Null, + "Temporary context should not return contextId" + ); + } + + [Fact] + [Trait("Feature", "NuGetPackagesParameter")] + public async Task EvaluateCsharp_CreateContextWithPackages_ThenUseInSubsequentCalls() + { + // Packages MUST be specified when creating the context + // They persist for all subsequent calls in that context + + // Arrange - Create context with packages at creation time + var nugetPackages = new[] + { + new NuGetPackageSpec { PackageName = "Humanizer", Version = "3.0.1" }, + }; + + var createResult = await ReplTools.EvaluateCsharp( + _scriptingService, + _contextManager, + _nugetService, + "var x = 10;", + nugetPackages: nugetPackages, + createContext: true + ); + + var json = TestJsonContext.SerializeDynamic(createResult); + var dict = TestJsonContext.DeserializeToDictionary(json); + var contextId = dict!["contextId"].GetString()!; + + // Act - Use package in same context (without specifying nugetPackages again) + var useResult = await ReplTools.EvaluateCsharp( + _scriptingService, + _contextManager, + _nugetService, + @"using Humanizer; return ""Test"".Humanize();", + contextId: contextId + ); + + // Assert + var useJson = TestJsonContext.SerializeDynamic(useResult); + var useDict = TestJsonContext.DeserializeToDictionary(useJson); + + Assert.NotNull(useDict); + Assert.True(useDict["success"].GetBoolean(), "Package should persist in context"); + Assert.Equal("Test", useDict["returnValue"].GetString()); + } + + [Fact] + [Trait("Feature", "NuGetPackagesParameter")] + public async Task EvaluateCsharp_MultiplePackages_ShouldAllBeAvailable() + { + // Test loading multiple packages at context creation + + // Arrange + var nugetPackages = new[] + { + new NuGetPackageSpec { PackageName = "Newtonsoft.Json", Version = "13.0.3" }, + new NuGetPackageSpec { PackageName = "Humanizer", Version = "3.0.1" }, + }; + + var createResult = await ReplTools.EvaluateCsharp( + _scriptingService, + _contextManager, + _nugetService, + "var x = 1;", + nugetPackages: nugetPackages, + createContext: true + ); + + var json = TestJsonContext.SerializeDynamic(createResult); + var dict = TestJsonContext.DeserializeToDictionary(json); + var contextId = dict!["contextId"].GetString()!; + + // Act - Use both packages + var result = await ReplTools.EvaluateCsharp( + _scriptingService, + _contextManager, + _nugetService, + @"using Newtonsoft.Json; + using Humanizer; + var obj = new { Value = ""PascalCase"".Humanize() }; + return JsonConvert.SerializeObject(obj);", + contextId: contextId + ); + + // Assert + var resultJson = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(resultJson); + + Assert.NotNull(resultDict); + Assert.True(resultDict["success"].GetBoolean(), "Both packages should be available"); + Assert.Contains("Pascal case", resultDict["returnValue"].GetString()); + } + + #endregion + + #region Critical Issue #2: GetDocumentation Fails for Core Types + + [Fact] + [Trait("Bug", "DocumentationLookup")] + public async Task BUG_GetDocumentation_SystemString_ShouldReturnDocumentation() + { + // Currently FAILS - returns null or "not found" + // Should return documentation for System.String + + // Act + var result = await _documentationService.GetDocumentationAsync("System.String"); + + // Assert + Assert.NotNull(result); + Assert.Equal("System.String", result.SymbolName); + Assert.False(string.IsNullOrEmpty(result.Summary), "Summary should not be empty"); + } + + [Fact] + [Trait("Bug", "DocumentationLookup")] + public async Task BUG_GetDocumentation_SystemConsole_ShouldReturnDocumentation() + { + // Currently FAILS + + // Act + var result = await _documentationService.GetDocumentationAsync("System.Console"); + + // Assert + Assert.NotNull(result); + Assert.Equal("System.Console", result.SymbolName); + Assert.NotNull(result.Summary); + } + + [Fact] + [Trait("Bug", "DocumentationLookup")] + public async Task BUG_GetDocumentation_CommonTypes_ShouldAllWork() + { + // Test common types that are documented in prompts + // Currently FAILS + + var commonTypes = new[] + { + "System.String", + "System.Int32", + "System.Console", + "System.IO.File", + "System.Linq.Enumerable", + }; + + foreach (var typeName in commonTypes) + { + // Act + var result = await _documentationService.GetDocumentationAsync(typeName); + + // Assert + Assert.NotNull(result); + Assert.False( + string.IsNullOrEmpty(result.Summary), + $"Documentation for {typeName} should have a summary" + ); + } + } + + [Fact] + [Trait("Bug", "DocumentationLookup")] + public async Task BUG_DocumentationTools_SystemString_ShouldReturnSuccess() + { + // Test the MCP tool directly + // Currently FAILS + + // Act + var result = await DocumentationTools.GetDocumentation( + _documentationService, + "System.String" + ); + + // Assert - Tool should return success response + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + Assert.NotNull(resultDict); + Assert.True( + resultDict["found"].GetBoolean(), + "GetDocumentation tool should find System.String" + ); + Assert.False( + string.IsNullOrEmpty(resultDict["summary"].GetString()), + "Summary should not be empty" + ); + } + + #endregion + + #region Critical Issue #3: Context State Errors + + [Fact] + [Trait("Bug", "ContextState")] + public async Task BUG_EvaluateCsharp_WithContextId_ShouldNotFailWithGenericError() + { + // Test that context operations provide detailed errors + // Currently FAILS with "An error occurred" + + // Arrange - Create context + var createResult = await ReplTools.EvaluateCsharp( + _scriptingService, + _contextManager, + _nugetService, + "var x = 10;", + createContext: true + ); + + var json = TestJsonContext.SerializeDynamic(createResult); + var dict = TestJsonContext.DeserializeToDictionary(json); + var contextId = dict!["contextId"].GetString()!; + + // Act - Continue with context + var continueResult = await ReplTools.EvaluateCsharp( + _scriptingService, + _contextManager, + _nugetService, + "return x * 2;", + contextId: contextId + ); + + // Assert - Should succeed or provide detailed error + var continueJson = TestJsonContext.SerializeDynamic(continueResult); + var continueDict = JsonSerializer.Deserialize>( + continueJson + ); + + Assert.NotNull(continueDict); + + if (!continueDict["success"].GetBoolean()) + { + // If it fails, error should be detailed, not generic + var errors = continueDict["errors"].EnumerateArray().ToList(); + Assert.NotEmpty(errors); + Assert.All( + errors, + error => + Assert.DoesNotContain( + "An error occurred", + error.GetProperty("message").GetString(), + StringComparison.OrdinalIgnoreCase + ) + ); + } + else + { + // Should succeed and return 20 + Assert.Equal(20, continueDict["returnValue"].GetInt32()); + } + } + + [Fact] + [Trait("Bug", "ContextState")] + public async Task BUG_EvaluateCsharp_InvalidContextId_ShouldProvideHelpfulError() + { + // Test error message quality for invalid context + // Currently may return generic error + + // Act - Use non-existent context + var result = await ReplTools.EvaluateCsharp( + _scriptingService, + _contextManager, + _nugetService, + "return 42;", + contextId: "non-existent-context-id" + ); + + // Assert - Should provide helpful error + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + Assert.NotNull(resultDict); + Assert.False(resultDict["success"].GetBoolean()); + + var errors = resultDict["errors"].EnumerateArray().ToList(); + Assert.NotEmpty(errors); + + var errorMessage = errors[0].GetProperty("message").GetString()!; + Assert.Contains("context", errorMessage, StringComparison.OrdinalIgnoreCase); + Assert.DoesNotContain("An error occurred", errorMessage); + } + + #endregion +} diff --git a/tests/RoslynStone.Tests/DiagnosticHelpersTests.cs b/tests/RoslynStone.Tests/DiagnosticHelpersTests.cs new file mode 100644 index 0000000000000000000000000000000000000000..41fae9953e6256a520f95b4285f38526d8643c64 --- /dev/null +++ b/tests/RoslynStone.Tests/DiagnosticHelpersTests.cs @@ -0,0 +1,251 @@ +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.CSharp; +using RoslynStone.Infrastructure.Functional; + +namespace RoslynStone.Tests; + +/// +/// Tests for DiagnosticHelpers functional helpers +/// +[Trait("Category", "Unit")] +[Trait("Component", "Functional")] +public class DiagnosticHelpersTests +{ + [Fact] + [Trait("Feature", "Conversion")] + public void ToCompilationError_ValidDiagnostic_ConvertsCorrectly() + { + // Arrange + var code = "int x = \"string\";"; // Type mismatch + var tree = CSharpSyntaxTree.ParseText(code); + var compilation = CSharpCompilation + .Create("test") + .AddSyntaxTrees(tree) + .AddReferences(MetadataReference.CreateFromFile(typeof(object).Assembly.Location)); + + var diagnostics = compilation.GetDiagnostics(); + var errorDiagnostic = diagnostics.First(d => d.Severity == DiagnosticSeverity.Error); + + // Act + var error = errorDiagnostic.ToCompilationError(); + + // Assert + Assert.NotNull(error); + Assert.NotEmpty(error.Code); + Assert.NotEmpty(error.Message); + Assert.NotEmpty(error.Severity); + Assert.True(error.Line > 0); + Assert.True(error.Column > 0); + } + + [Fact] + [Trait("Feature", "Filtering")] + public void ToCompilationErrors_MixedDiagnostics_FiltersErrorsAndWarnings() + { + // Arrange + var code = + @" +using System; +int x = ""string""; // Error +#pragma warning disable CS0168 +int y; // Warning (unused variable) +#pragma warning restore CS0168 +"; + var tree = CSharpSyntaxTree.ParseText(code); + var compilation = CSharpCompilation + .Create("test") + .AddSyntaxTrees(tree) + .AddReferences(MetadataReference.CreateFromFile(typeof(object).Assembly.Location)); + + var diagnostics = compilation.GetDiagnostics(); + + // Act + var errors = diagnostics.ToCompilationErrors(); + + // Assert + Assert.NotEmpty(errors); + Assert.All(errors, e => Assert.True(e.Severity == "Error" || e.Severity == "Warning")); + } + + [Fact] + [Trait("Feature", "Filtering")] + public void ToCompilationErrors_OnlyInfoDiagnostics_ReturnsEmpty() + { + // Arrange - Valid code with no errors or warnings + var code = "int x = 42;"; + var tree = CSharpSyntaxTree.ParseText(code); + var compilation = CSharpCompilation + .Create("test") + .AddSyntaxTrees(tree) + .AddReferences(MetadataReference.CreateFromFile(typeof(object).Assembly.Location)); + + var diagnostics = compilation + .GetDiagnostics() + .Where(d => + d.Severity == DiagnosticSeverity.Info || d.Severity == DiagnosticSeverity.Hidden + ); + + // Act + var errors = diagnostics.ToCompilationErrors(); + + // Assert + Assert.Empty(errors); + } + + [Fact] + [Trait("Feature", "Partitioning")] + public void PartitionDiagnostics_ErrorsAndWarnings_PartitionsCorrectly() + { + // Arrange - Code with both errors and warnings + var code = + @" +using System; +int x = ""string""; // Error: CS0029 +int y; // Warning: CS0168 (unused variable) +"; + var tree = CSharpSyntaxTree.ParseText(code); + var compilation = CSharpCompilation + .Create("test") + .AddSyntaxTrees(tree) + .AddReferences(MetadataReference.CreateFromFile(typeof(object).Assembly.Location)); + + var diagnostics = compilation.GetDiagnostics(); + + // Act + var (errors, warnings) = diagnostics.PartitionDiagnostics(); + + // Assert + Assert.NotEmpty(errors); + Assert.All(errors, e => Assert.Equal("Error", e.Severity)); + + // Warnings might be present depending on compilation settings + Assert.All(warnings, w => Assert.Equal("Warning", w.Severity)); + } + + [Fact] + [Trait("Feature", "Partitioning")] + public void PartitionDiagnostics_OnlyErrors_ReturnsEmptyWarnings() + { + // Arrange - Code with only errors + var code = + @" +int x = ""string""; // Error +int y = ""another string""; // Another error +"; + var tree = CSharpSyntaxTree.ParseText(code); + var compilation = CSharpCompilation + .Create("test") + .AddSyntaxTrees(tree) + .AddReferences(MetadataReference.CreateFromFile(typeof(object).Assembly.Location)); + + var diagnostics = compilation + .GetDiagnostics() + .Where(d => d.Severity == DiagnosticSeverity.Error); + + // Act + var (errors, warnings) = diagnostics.PartitionDiagnostics(); + + // Assert + Assert.NotEmpty(errors); + Assert.Empty(warnings); + } + + [Fact] + [Trait("Feature", "Partitioning")] + public void PartitionDiagnostics_OnlyWarnings_ReturnsEmptyErrors() + { + // Arrange - Code with only warnings + var code = + @" +using System; +int x; // CS0168: Variable is declared but never used +int y; // CS0168: Variable is declared but never used +"; + var tree = CSharpSyntaxTree.ParseText( + code, + // ReSharper disable once RedundantNameQualifier - Explicit for clarity + CSharpParseOptions.Default.WithLanguageVersion( + Microsoft.CodeAnalysis.CSharp.LanguageVersion.Latest + ) + ); + var compilation = CSharpCompilation + .Create( + "test", + options: new CSharpCompilationOptions( + OutputKind.DynamicallyLinkedLibrary, + warningLevel: 4 + ) + ) + .AddSyntaxTrees(tree) + .AddReferences(MetadataReference.CreateFromFile(typeof(object).Assembly.Location)); + + var diagnostics = compilation + .GetDiagnostics() + .Where(d => d.Severity == DiagnosticSeverity.Warning); + + // Act + var (errors, warnings) = diagnostics.PartitionDiagnostics(); + + // Assert + Assert.Empty(errors); + Assert.NotEmpty(warnings); + } + + [Fact] + [Trait("Feature", "Check")] + public void HasErrors_DiagnosticsWithErrors_ReturnsTrue() + { + // Arrange + var code = "int x = \"string\";"; // Error + var tree = CSharpSyntaxTree.ParseText(code); + var compilation = CSharpCompilation + .Create("test") + .AddSyntaxTrees(tree) + .AddReferences(MetadataReference.CreateFromFile(typeof(object).Assembly.Location)); + + var diagnostics = compilation.GetDiagnostics(); + + // Act + var hasErrors = diagnostics.HasErrors(); + + // Assert + Assert.True(hasErrors); + } + + [Fact] + [Trait("Feature", "Check")] + public void HasErrors_DiagnosticsWithoutErrors_ReturnsFalse() + { + // Arrange + var code = "int x = 42;"; // Valid code + var tree = CSharpSyntaxTree.ParseText(code); + var compilation = CSharpCompilation + .Create("test") + .AddSyntaxTrees(tree) + .AddReferences(MetadataReference.CreateFromFile(typeof(object).Assembly.Location)); + + var diagnostics = compilation + .GetDiagnostics() + .Where(d => d.Severity != DiagnosticSeverity.Error); + + // Act + var hasErrors = diagnostics.HasErrors(); + + // Assert + Assert.False(hasErrors); + } + + [Fact] + [Trait("Feature", "Check")] + public void HasErrors_EmptyDiagnostics_ReturnsFalse() + { + // Arrange + var diagnostics = Array.Empty(); + + // Act + var hasErrors = diagnostics.HasErrors(); + + // Assert + Assert.False(hasErrors); + } +} diff --git a/tests/RoslynStone.Tests/DocumentationServiceNuGetIntegrationTests.cs b/tests/RoslynStone.Tests/DocumentationServiceNuGetIntegrationTests.cs new file mode 100644 index 0000000000000000000000000000000000000000..87b3cb7f06c967a288e28c5933c6b2e85339bb21 --- /dev/null +++ b/tests/RoslynStone.Tests/DocumentationServiceNuGetIntegrationTests.cs @@ -0,0 +1,125 @@ +using RoslynStone.Infrastructure.Services; + +namespace RoslynStone.Tests; + +/// +/// Integration tests for DocumentationService with NuGet packages +/// +[Trait("Category", "Integration")] +[Trait("Component", "Documentation")] +public class DocumentationServiceNuGetIntegrationTests : IDisposable +{ + private readonly NuGetService _nugetService; + private readonly DocumentationService _service; + + public DocumentationServiceNuGetIntegrationTests() + { + _nugetService = new NuGetService(); + _service = new DocumentationService(_nugetService); + } + + [Fact] + [Trait("Feature", "NuGetPackages")] + public async Task GetDocumentationAsync_NewtonsoftJsonJsonConvert_ReturnsDocumentationIfInstalled() + { + // Arrange + var symbolName = "Newtonsoft.Json.JsonConvert"; + var packageId = "Newtonsoft.Json"; + + // Act + var result = await _service.GetDocumentationAsync(symbolName, packageId); + + // Assert + // If the package is installed locally (from other tests or builds), + // this should find documentation. Otherwise, it may return null. + // This test ensures the lookup doesn't throw exceptions. + if (result != null) + { + Assert.Equal(symbolName, result.SymbolName); + Assert.NotNull(result.Summary); + Assert.NotEmpty(result.Summary); + } + } + + [Fact] + [Trait("Feature", "NuGetPackages")] + public async Task GetDocumentationAsync_CommonNuGetPackage_HandlesGracefully() + { + // Arrange - Try a few common packages that might be installed + var testCases = new[] + { + ("Microsoft.Extensions.Logging.ILogger", "Microsoft.Extensions.Logging.Abstractions"), + ("Newtonsoft.Json.JsonSerializer", "Newtonsoft.Json"), + ("System.Text.Json.JsonSerializer", "System.Text.Json"), + }; + + foreach (var (symbolName, packageId) in testCases) + { + // Act + var result = await _service.GetDocumentationAsync(symbolName, packageId); + + // Assert - Should not throw, may or may not find documentation + Assert.True( + result == null || result.SymbolName == symbolName, + $"Symbol name mismatch for {symbolName}" + ); + } + } + + [Fact] + [Trait("Feature", "NuGetPackages")] + public async Task GetDocumentationAsync_TypeInInstalledPackage_RetrievesCorrectMemberTypes() + { + // Arrange + var symbolName = "Newtonsoft.Json.JsonConvert"; + var packageId = "Newtonsoft.Json"; + + // Act + var result = await _service.GetDocumentationAsync(symbolName, packageId); + + // Assert + if (result != null) + { + // Verify that the documentation structure is correct + Assert.NotNull(result.SymbolName); + Assert.NotNull(result.Summary); + Assert.NotNull(result.Parameters); + Assert.NotNull(result.Exceptions); + } + } + + [Fact] + [Trait("Feature", "NuGetPackages")] + public async Task GetDocumentationAsync_InvalidPackageId_ReturnsNull() + { + // Arrange + var symbolName = "Some.Type.Name"; + var packageId = "This.Package.Does.Not.Exist.123456789"; + + // Act + var result = await _service.GetDocumentationAsync(symbolName, packageId); + + // Assert + Assert.Null(result); + } + + [Fact] + [Trait("Feature", "NuGetPackages")] + public async Task GetDocumentationAsync_EmptyPackageId_ReturnsFallbackBehavior() + { + // Arrange + var symbolName = "System.String"; + var packageId = ""; + + // Act + var result = await _service.GetDocumentationAsync(symbolName, packageId); + + // Assert - Empty package ID should fall back to normal behavior + Assert.True(result == null || result.SymbolName == symbolName); + } + + public void Dispose() + { + _nugetService.Dispose(); + } +} diff --git a/tests/RoslynStone.Tests/DocumentationServiceTests.cs b/tests/RoslynStone.Tests/DocumentationServiceTests.cs new file mode 100644 index 0000000000000000000000000000000000000000..29f0fde583fd026c22744eb1826c797e73a32aad --- /dev/null +++ b/tests/RoslynStone.Tests/DocumentationServiceTests.cs @@ -0,0 +1,235 @@ +using RoslynStone.Infrastructure.Services; + +namespace RoslynStone.Tests; + +/// +/// Tests for DocumentationService +/// +[Trait("Category", "Unit")] +[Trait("Component", "Documentation")] +public class DocumentationServiceTests +{ + private readonly DocumentationService _service; + + public DocumentationServiceTests() + { + _service = new DocumentationService(); + } + + [Fact] + [Trait("Feature", "Lookup")] + public async Task GetDocumentationAsync_StringType_ReturnsDocumentation() + { + // Arrange + var symbolName = "System.String"; + + // Act + _ = await _service.GetDocumentationAsync(symbolName); + + // Assert + // Documentation may or may not be available depending on the runtime + // This test primarily ensures the method doesn't throw + Assert.NotNull(_service); + } + + [Fact] + [Trait("Feature", "Validation")] + public async Task GetDocumentationAsync_InvalidSymbol_ReturnsNull() + { + // Arrange + var symbolName = "NonExistent.Type.Name"; + + // Act + var result = await _service.GetDocumentationAsync(symbolName); + + // Assert + Assert.Null(result); + } + + [Fact] + [Trait("Feature", "Lookup")] + public async Task GetDocumentationAsync_ValidType_ReturnsDocumentationOrNull() + { + // Arrange + var symbolName = "System.Int32"; + + // Act + var result = await _service.GetDocumentationAsync(symbolName); + + // Assert - Documentation may or may not be available + // Either null (no XML docs) or valid DocumentationInfo + if (result != null) + { + Assert.Equal(symbolName, result.SymbolName); + Assert.NotNull(result.Parameters); + Assert.NotNull(result.Exceptions); + } + } + + [Fact] + [Trait("Feature", "Lookup")] + public async Task GetDocumentationAsync_ConsoleType_ReturnsDocumentationOrNull() + { + // Arrange + var symbolName = "System.Console"; + + // Act + var result = await _service.GetDocumentationAsync(symbolName); + + // Assert + // Documentation availability depends on runtime + if (result != null) + { + Assert.Equal(symbolName, result.SymbolName); + } + } + + [Fact] + [Trait("Feature", "Lookup")] + public async Task GetDocumentationAsync_PartialTypeName_ReturnsDocumentationOrNull() + { + // Arrange + var symbolName = "String"; + + // Act + var result = await _service.GetDocumentationAsync(symbolName); + + // Assert + // May find System.String or return null + Assert.True(result == null || result.SymbolName == symbolName); + } + + [Fact] + [Trait("Feature", "CacheSupport")] + public async Task GetDocumentationAsync_SameSymbolTwice_UsesCache() + { + // Arrange + var symbolName = "System.String"; + + // Act + var result1 = await _service.GetDocumentationAsync(symbolName); + var result2 = await _service.GetDocumentationAsync(symbolName); + + // Assert - Should return same result (cached or both null) + if (result1 == null) + { + Assert.Null(result2); + } + else + { + Assert.NotNull(result2); + Assert.Equal(result1.SymbolName, result2.SymbolName); + } + } + + [Fact] + [Trait("Feature", "EdgeCases")] + public async Task GetDocumentationAsync_EmptyString_ReturnsNull() + { + // Arrange + var symbolName = ""; + + // Act + var result = await _service.GetDocumentationAsync(symbolName); + + // Assert + Assert.Null(result); + } + + [Fact] + [Trait("Feature", "EdgeCases")] + public async Task GetDocumentationAsync_SpecialCharacters_ReturnsNull() + { + // Arrange + var symbolName = "System.@#$%"; + + // Act + var result = await _service.GetDocumentationAsync(symbolName); + + // Assert + Assert.Null(result); + } + + [Fact] + [Trait("Feature", "GenericTypes")] + public async Task GetDocumentationAsync_GenericType_ReturnsDocumentationOrNull() + { + // Arrange + var symbolName = "System.Collections.Generic.List`1"; + + // Act + var result = await _service.GetDocumentationAsync(symbolName); + + // Assert + // Generic type notation may or may not be found + Assert.True(result == null || !string.IsNullOrEmpty(result.SymbolName)); + } + + [Fact] + [Trait("Feature", "NuGetPackages")] + public async Task GetDocumentationAsync_WithPackageId_ReturnsDocumentationIfAvailable() + { + // Arrange + using var nugetService = new NuGetService(); + var service = new DocumentationService(nugetService); + var symbolName = "Newtonsoft.Json.JsonConvert"; + var packageId = "Newtonsoft.Json"; + + // Act + var result = await service.GetDocumentationAsync(symbolName, packageId); + + // Assert + // Documentation may or may not be available depending on if package is installed + // This test ensures the method doesn't throw + Assert.True(result == null || result.SymbolName == symbolName); + } + + [Fact] + [Trait("Feature", "NuGetPackages")] + public async Task GetDocumentationAsync_WithoutNuGetService_ReturnsNull() + { + // Arrange + var service = new DocumentationService(nugetService: null); + var symbolName = "Newtonsoft.Json.JsonConvert"; + var packageId = "Newtonsoft.Json"; + + // Act + var result = await service.GetDocumentationAsync(symbolName, packageId); + + // Assert - Should return null when NuGet service is not available + Assert.Null(result); + } + + [Fact] + [Trait("Feature", "NuGetPackages")] + public async Task GetDocumentationAsync_NonExistentPackage_ReturnsNull() + { + // Arrange + using var nugetService = new NuGetService(); + var service = new DocumentationService(nugetService); + var symbolName = "Some.Type.Name"; + var packageId = "NonExistent.Package.That.Does.Not.Exist"; + + // Act + var result = await service.GetDocumentationAsync(symbolName, packageId); + + // Assert + Assert.Null(result); + } + + [Fact] + [Trait("Feature", "BackwardCompatibility")] + public async Task GetDocumentationAsync_WithoutPackageId_UsesOriginalBehavior() + { + // Arrange + using var nugetService = new NuGetService(); + var service = new DocumentationService(nugetService); + var symbolName = "System.String"; + + // Act - Using the original method signature + var result = await service.GetDocumentationAsync(symbolName); + + // Assert - Should still work as before + Assert.True(result == null || result.SymbolName == symbolName); + } +} diff --git a/tests/RoslynStone.Tests/GuidancePromptsTests.cs b/tests/RoslynStone.Tests/GuidancePromptsTests.cs new file mode 100644 index 0000000000000000000000000000000000000000..ca9c2e87504630394a29e9786e22c483e385357f --- /dev/null +++ b/tests/RoslynStone.Tests/GuidancePromptsTests.cs @@ -0,0 +1,169 @@ +using RoslynStone.Infrastructure.Tools; + +namespace RoslynStone.Tests; + +/// +/// Tests for MCP guidance prompts +/// +[Trait("Category", "Unit")] +[Trait("Component", "MCP")] +public class GuidancePromptsTests +{ + [Fact] + [Trait("Feature", "Prompts")] + public async Task QuickStart_ReturnsQuickStartGuide() + { + // Act + var result = await GuidancePrompts.QuickStart(); + + // Assert + Assert.NotNull(result); + Assert.NotEmpty(result); + Assert.Contains("Quick Start", result); + Assert.Contains("EvaluateCsharp", result); + Assert.Contains("nugetPackages", result); + Assert.Contains("Resources", result); + } + + [Fact] + [Trait("Feature", "Prompts")] + [Trait("Feature", "NET10Directives")] + public async Task QuickStart_ContainsPackageDirectiveExample() + { + // Act + var result = await GuidancePrompts.QuickStart(); + + // Assert + Assert.Contains("#:package", result); + Assert.Contains("Humanizer@2.14.1", result); + Assert.Contains("New .NET 10 Syntax", result); + Assert.Contains("#:sdk", result); + } + + [Fact] + [Trait("Feature", "Prompts")] + public async Task ComprehensiveGuide_ReturnsDetailedGuide() + { + // Act + var result = await GuidancePrompts.ComprehensiveGuide(); + + // Assert + Assert.NotNull(result); + Assert.NotEmpty(result); + Assert.Contains("Complete Guide", result); + Assert.Contains("Single-File", result); + Assert.Contains("EvaluateCsharp", result); + Assert.Contains("ValidateCsharp", result); + Assert.Contains("doc://", result); + Assert.Contains("NuGet", result); + } + + [Fact] + [Trait("Feature", "Prompts")] + [Trait("Feature", "NET10Directives")] + public async Task ComprehensiveGuide_ContainsPackageDirective() + { + // Act + var result = await GuidancePrompts.ComprehensiveGuide(); + + // Assert + Assert.Contains("#:package", result); + Assert.Contains("Newtonsoft.Json@13.0.3", result); + Assert.Contains("dotnet run", result); + Assert.Contains("self-contained", result, StringComparison.OrdinalIgnoreCase); + } + + [Fact] + [Trait("Feature", "Prompts")] + [Trait("Feature", "NET10Directives")] + public async Task ComprehensiveGuide_ContainsSdkDirective() + { + // Act + var result = await GuidancePrompts.ComprehensiveGuide(); + + // Assert + Assert.Contains("#:sdk", result); + Assert.Contains("Microsoft.NET.Sdk.Web", result); + Assert.Contains("WebApplication", result); + } + + [Fact] + [Trait("Feature", "Prompts")] + [Trait("Feature", "NET10Directives")] + public async Task ComprehensiveGuide_ContainsPackageDirectiveGuidance() + { + // Act + var result = await GuidancePrompts.ComprehensiveGuide(); + + // Assert + Assert.Contains("#:package", result); + Assert.Contains("Package directives", result, StringComparison.OrdinalIgnoreCase); + } + + [Fact] + [Trait("Feature", "Prompts")] + public async Task PackageGuide_ReturnsPackageGuide() + { + // Act + var result = await GuidancePrompts.PackageGuide(); + + // Assert + Assert.NotNull(result); + Assert.NotEmpty(result); + Assert.Contains("NuGet", result); + Assert.Contains("nuget://", result); + Assert.Contains("Newtonsoft.Json", result); + } + + [Fact] + [Trait("Feature", "Prompts")] + [Trait("Feature", "NET10Directives")] + public async Task PackageGuide_ContainsPackageDirective() + { + // Act + var result = await GuidancePrompts.PackageGuide(); + + // Assert + Assert.Contains("#:package", result); + Assert.Contains("Self-contained", result, StringComparison.OrdinalIgnoreCase); + Assert.Contains("Newtonsoft.Json@13.0.3", result); + Assert.Contains("CsvHelper@30.0.1", result); + } + + [Fact] + [Trait("Feature", "Prompts")] + [Trait("Feature", "NET10Directives")] + public async Task PackageGuide_ContainsPackageDirectiveInAllExamples() + { + // Act + var result = await GuidancePrompts.PackageGuide(); + + // Assert - Should contain #:package directive + Assert.Contains("#:package", result); + + // Assert - All 4 main examples should have package directives + Assert.Contains("#:package Newtonsoft.Json@13.0.3", result); + Assert.Contains("#:package Flurl.Http@4.0.0", result); + Assert.Contains("#:package CsvHelper@30.0.1", result); + Assert.Contains("#:package Humanizer@2.14.1", result); + + // Assert - Should mention self-contained + Assert.Contains("self-contained", result, StringComparison.OrdinalIgnoreCase); + } + + [Fact] + [Trait("Feature", "Prompts")] + public async Task DebuggingErrors_ReturnsDebugGuide() + { + // Act + var result = await GuidancePrompts.DebuggingErrors(); + + // Assert + Assert.NotNull(result); + Assert.NotEmpty(result); + Assert.Contains("Debugging", result); + Assert.Contains("ValidateCsharp", result); + Assert.Contains("Context-Aware", result); + Assert.Contains("Workflow", result); + } +} diff --git a/tests/RoslynStone.Tests/McpServerConfigurationTests.cs b/tests/RoslynStone.Tests/McpServerConfigurationTests.cs new file mode 100644 index 0000000000000000000000000000000000000000..fe108d67be6062255f75217f39c0590bbca17875 --- /dev/null +++ b/tests/RoslynStone.Tests/McpServerConfigurationTests.cs @@ -0,0 +1,229 @@ +using ModelContextProtocol.Server; +using RoslynStone.Infrastructure.Resources; +using RoslynStone.Infrastructure.Tools; + +namespace RoslynStone.Tests; + +/// +/// Tests for MCP server configuration and resource/tool discovery +/// +[Trait("Category", "Integration")] +[Trait("Component", "MCP")] +public class McpServerConfigurationTests +{ + [Fact] + [Trait("Feature", "ToolDiscovery")] + public void ReplTools_HasExpectedToolCount() + { + // This test verifies that we have the expected number of tools + // to detect if tools are accidentally removed or duplicated + + var methods = typeof(ReplTools) + .GetMethods() + .Where(m => m.GetCustomAttributes(typeof(McpServerToolAttribute), false).Any()) + .ToList(); + + // We expect: EvaluateCsharp, ValidateCsharp, ResetRepl, GetReplInfo + Assert.Equal(4, methods.Count); + } + + [Fact] + [Trait("Feature", "ToolDiscovery")] + public void NuGetTools_HasExpectedToolCount() + { + var methods = typeof(NuGetTools) + .GetMethods() + .Where(m => m.GetCustomAttributes(typeof(McpServerToolAttribute), false).Any()) + .ToList(); + + // We expect: SearchNuGetPackages, GetNuGetPackageVersions, GetNuGetPackageReadme (LoadNuGetPackage removed for security) + Assert.Equal(3, methods.Count); + } + + [Fact] + [Trait("Feature", "ToolDiscovery")] + public void DocumentationTools_HasExpectedToolCount() + { + var methods = typeof(DocumentationTools) + .GetMethods() + .Where(m => m.GetCustomAttributes(typeof(McpServerToolAttribute), false).Any()) + .ToList(); + + // We expect: GetDocumentation + Assert.Single(methods); + } + + [Fact] + [Trait("Feature", "ResourceDiscovery")] + public void DocumentationResource_HasExpectedResourceCount() + { + var methods = typeof(DocumentationResource) + .GetMethods() + .Where(m => m.GetCustomAttributes(typeof(McpServerResourceAttribute), false).Any()) + .ToList(); + + // We expect: GetDocumentation (ListDocumentation removed) + Assert.Single(methods); + } + + [Fact] + [Trait("Feature", "ResourceDiscovery")] + public void NuGetSearchResource_HasExpectedResourceCount() + { + var methods = typeof(NuGetSearchResource) + .GetMethods() + .Where(m => m.GetCustomAttributes(typeof(McpServerResourceAttribute), false).Any()) + .ToList(); + + // We expect: SearchPackages (ListSearches removed as MCP handles resource listing) + Assert.Single(methods); + } + + [Fact] + [Trait("Feature", "ResourceDiscovery")] + public void NuGetPackageResource_HasExpectedResourceCount() + { + var methods = typeof(NuGetPackageResource) + .GetMethods() + .Where(m => m.GetCustomAttributes(typeof(McpServerResourceAttribute), false).Any()) + .ToList(); + + // We expect: GetPackageVersions, GetPackageReadme (ListPackages removed) + Assert.Equal(2, methods.Count); + } + + [Fact] + [Trait("Feature", "ResourceDiscovery")] + public void ReplStateResource_HasExpectedResourceCount() + { + var methods = typeof(ReplStateResource) + .GetMethods() + .Where(m => m.GetCustomAttributes(typeof(McpServerResourceAttribute), false).Any()) + .ToList(); + + // We expect: GetReplState and GetReplSessionState (ListSessions removed) + Assert.Equal(2, methods.Count); + } + + [Fact] + [Trait("Feature", "PromptDiscovery")] + public void GuidancePrompts_HasExpectedPromptCount() + { + var methods = typeof(GuidancePrompts) + .GetMethods() + .Where(m => m.GetCustomAttributes(typeof(McpServerPromptAttribute), false).Any()) + .ToList(); + + // We expect: QuickStart, ComprehensiveGuide, PackageGuide, DebuggingErrors + Assert.Equal(4, methods.Count); + } + + [Fact] + [Trait("Feature", "ToolDiscovery")] + public void AllTools_HaveDescriptions() + { + // Verify all tools have [Description] attributes for MCP protocol + var toolTypes = new[] { typeof(ReplTools), typeof(NuGetTools), typeof(DocumentationTools) }; + + foreach (var toolType in toolTypes) + { + var methods = toolType + .GetMethods() + .Where(m => m.GetCustomAttributes(typeof(McpServerToolAttribute), false).Any()) + .ToList(); + + foreach (var method in methods) + { + var descriptionAttr = method + .GetCustomAttributes(typeof(System.ComponentModel.DescriptionAttribute), false) + .FirstOrDefault(); + + Assert.NotNull(descriptionAttr); + + var description = ( + (System.ComponentModel.DescriptionAttribute)descriptionAttr + ).Description; + Assert.NotEmpty(description); + + // Verify description is substantial (not just a few words) + Assert.True( + description.Length > 50, + $"Tool {toolType.Name}.{method.Name} has a description that is too short: {description}" + ); + } + } + } + + [Fact] + [Trait("Feature", "ResourceDiscovery")] + public void AllResources_HaveDescriptions() + { + // Verify all resources have [Description] attributes for MCP protocol + var resourceTypes = new[] + { + typeof(DocumentationResource), + typeof(NuGetSearchResource), + typeof(NuGetPackageResource), + typeof(ReplStateResource), + }; + + foreach (var resourceType in resourceTypes) + { + var methods = resourceType + .GetMethods() + .Where(m => m.GetCustomAttributes(typeof(McpServerResourceAttribute), false).Any()) + .ToList(); + + foreach (var method in methods) + { + var descriptionAttr = method + .GetCustomAttributes(typeof(System.ComponentModel.DescriptionAttribute), false) + .FirstOrDefault(); + + Assert.NotNull(descriptionAttr); + + var description = ( + (System.ComponentModel.DescriptionAttribute)descriptionAttr + ).Description; + Assert.NotEmpty(description); + + // Verify description is substantial + Assert.True( + description.Length > 20, + $"Resource {resourceType.Name}.{method.Name} has a description that is too short: {description}" + ); + } + } + } + + [Fact] + [Trait("Feature", "PromptDiscovery")] + public void AllPrompts_HaveDescriptions() + { + // Verify all prompts have [Description] attributes for MCP protocol + var methods = typeof(GuidancePrompts) + .GetMethods() + .Where(m => m.GetCustomAttributes(typeof(McpServerPromptAttribute), false).Any()) + .ToList(); + + foreach (var method in methods) + { + var descriptionAttr = method + .GetCustomAttributes(typeof(System.ComponentModel.DescriptionAttribute), false) + .FirstOrDefault(); + + Assert.NotNull(descriptionAttr); + + var description = ( + (System.ComponentModel.DescriptionAttribute)descriptionAttr + ).Description; + Assert.NotEmpty(description); + + // Verify description is substantial + Assert.True( + description.Length > 30, + $"Prompt {method.Name} has a description that is too short: {description}" + ); + } + } +} diff --git a/tests/RoslynStone.Tests/McpToolsIntegrationTests.cs b/tests/RoslynStone.Tests/McpToolsIntegrationTests.cs new file mode 100644 index 0000000000000000000000000000000000000000..0d566e5de4b7650ca21803974bee08bd54579d9d --- /dev/null +++ b/tests/RoslynStone.Tests/McpToolsIntegrationTests.cs @@ -0,0 +1,587 @@ +using System.Text.Json; +using RoslynStone.Infrastructure.Services; +using RoslynStone.Infrastructure.Tools; +using RoslynStone.Tests.Serialization; + +namespace RoslynStone.Tests; + +/// +/// Integration tests for MCP tools +/// +[Trait("Category", "Integration")] +[Trait("Component", "MCP")] +public class McpToolsIntegrationTests : IDisposable +{ + private readonly RoslynScriptingService _scriptingService; + private readonly IReplContextManager _contextManager; + private readonly NuGetService _nugetService; + + public McpToolsIntegrationTests() + { + _scriptingService = new RoslynScriptingService(); + _contextManager = new ReplContextManager(); + _nugetService = new NuGetService(); + } + + public void Dispose() + { + // ReSharper disable once ConditionalAccessQualifierIsNonNullableAccordingToAPIContract + _nugetService?.Dispose(); + } + + [Fact] + [Trait("Feature", "Evaluation")] + public async Task EvaluateCsharp_SimpleExpression_ReturnsCorrectResult() + { + // Arrange + var code = "2 + 2"; + + // Act - Using createContext: true to maintain stateful behavior + var result = await ReplTools.EvaluateCsharp( + _scriptingService, + _contextManager, + _nugetService, + code, + createContext: true + ); + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + // Assert + Assert.NotNull(resultDict); + Assert.True(resultDict["success"].GetBoolean()); + Assert.Equal(4, resultDict["returnValue"].GetInt32()); + Assert.True(resultDict.ContainsKey("contextId")); + } + + [Fact] + [Trait("Feature", "Evaluation")] + public async Task EvaluateCsharp_WithConsoleOutput_CapturesOutput() + { + // Arrange + var code = "Console.WriteLine(\"Test Output\"); 42"; + + // Act + var result = await ReplTools.EvaluateCsharp( + _scriptingService, + _contextManager, + _nugetService, + code + ); + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + // Assert + Assert.NotNull(resultDict); + Assert.True(resultDict["success"].GetBoolean()); + Assert.Equal(42, resultDict["returnValue"].GetInt32()); + Assert.Contains("Test Output", resultDict["output"].GetString()); + } + + [Fact] + [Trait("Feature", "Evaluation")] + public async Task EvaluateCsharp_CompilationError_ReturnsErrors() + { + // Arrange + var code = "int x = \"not a number\";"; + + // Act + var result = await ReplTools.EvaluateCsharp( + _scriptingService, + _contextManager, + _nugetService, + code + ); + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + // Assert + Assert.NotNull(resultDict); + Assert.False(resultDict["success"].GetBoolean()); + Assert.NotEmpty(resultDict["errors"].EnumerateArray()); + } + + [Fact] + [Trait("Feature", "Validation")] + public async Task ValidateCsharp_ValidCode_ReturnsValid() + { + // Arrange + var code = "int x = 42;"; + + // Act + var result = await ReplTools.ValidateCsharp(_scriptingService, _contextManager, code); + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + // Assert + Assert.NotNull(resultDict); + Assert.True(resultDict["isValid"].GetBoolean()); + } + + [Fact] + [Trait("Feature", "Validation")] + public async Task ValidateCsharp_InvalidCode_ReturnsErrors() + { + // Arrange + var code = "int x = \"not a number\";"; + + // Act + var result = await ReplTools.ValidateCsharp(_scriptingService, _contextManager, code); + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + // Assert + Assert.NotNull(resultDict); + Assert.False(resultDict["isValid"].GetBoolean()); + Assert.NotEmpty(resultDict["issues"].EnumerateArray()); + } + + [Fact] + [Trait("Feature", "Reset")] + public async Task ResetRepl_ClearsState() + { + // Arrange + var result1 = await ReplTools.EvaluateCsharp( + _scriptingService, + _contextManager, + _nugetService, + "int x = 42;", + createContext: true + ); + var json1 = JsonSerializer.Serialize(result1); + var resultDict1 = TestJsonContext.DeserializeToDictionary(json1); + var contextId = resultDict1!["contextId"].GetString(); + + // Act + ReplTools.ResetRepl(_contextManager, contextId); + var result = await ReplTools.EvaluateCsharp( + _scriptingService, + _contextManager, + _nugetService, + "x", + contextId + ); + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + // Assert + Assert.NotNull(resultDict); + Assert.False(resultDict["success"].GetBoolean()); // x should not be defined anymore + } + + [Fact] + [Trait("Feature", "StateManagement")] + public async Task EvaluateCsharp_PreservesStateBetweenCalls() + { + // Arrange + var service = new RoslynScriptingService(); // Fresh instance + var contextMgr = new ReplContextManager(); + using var nugetSvc = new NuGetService(); + + // Act - First execution creates context + var result1 = await ReplTools.EvaluateCsharp( + service, + contextMgr, + nugetSvc, + "int value = 100;", + createContext: true + ); + var json1 = JsonSerializer.Serialize(result1); + var result1Dict = TestJsonContext.DeserializeToDictionary(json1); + var contextId = result1Dict!["contextId"].GetString(); + + // Second execution uses same context + var result2 = await ReplTools.EvaluateCsharp( + service, + contextMgr, + nugetSvc, + "value + 50", + contextId + ); + + var json2 = JsonSerializer.Serialize(result2); + var result2Dict = TestJsonContext.DeserializeToDictionary(json2); + + // Assert + Assert.NotNull(result1Dict); + Assert.NotNull(result2Dict); + Assert.True(result1Dict["success"].GetBoolean()); + Assert.True(result2Dict["success"].GetBoolean()); + Assert.Equal(150, result2Dict["returnValue"].GetInt32()); + } + + [Fact] + [Trait("Feature", "Async")] + public async Task EvaluateCsharp_AsyncCode_ExecutesCorrectly() + { + // Arrange + var code = "await Task.Delay(10); \"completed\""; + + // Act + var result = await ReplTools.EvaluateCsharp( + _scriptingService, + _contextManager, + _nugetService, + code + ); + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + // Assert + Assert.NotNull(resultDict); + Assert.True(resultDict["success"].GetBoolean()); + Assert.Equal("completed", resultDict["returnValue"].GetString()); + } + + [Fact] + [Trait("Feature", "ContextManagement")] + public async Task EvaluateCsharp_InvalidContextId_ReturnsProperError() + { + // Arrange + var invalidContextId = "invalid-context-id-12345"; + var code = "2 + 2"; + + // Act + var result = await ReplTools.EvaluateCsharp( + _scriptingService, + _contextManager, + _nugetService, + code, + invalidContextId + ); + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + // Assert + Assert.NotNull(resultDict); + Assert.False(resultDict["success"].GetBoolean()); + + // Check new error structure (errors array) + Assert.True(resultDict.TryGetValue("errors", out var errorsElement)); + var errors = errorsElement.EnumerateArray().ToList(); + Assert.NotEmpty(errors); + Assert.Equal("CONTEXT_NOT_FOUND", errors[0].GetProperty("code").GetString()); + Assert.Contains("not found or expired", errors[0].GetProperty("message").GetString()); + } + + [Fact] + [Trait("Feature", "ContextManagement")] + public async Task EvaluateCsharp_ExpiredContextId_ReturnsProperError() + { + // Arrange - Create context manager with very short timeout + var shortTimeout = TimeSpan.FromMilliseconds(50); + var contextMgr = new ReplContextManager(contextTimeout: shortTimeout); + using var nugetSvc = new NuGetService(); + + // Create a context and let it expire + var result1 = await ReplTools.EvaluateCsharp( + _scriptingService, + contextMgr, + nugetSvc, + "int x = 42;", + createContext: true + ); + var json1 = JsonSerializer.Serialize(result1); + var result1Dict = TestJsonContext.DeserializeToDictionary(json1); + var contextId = result1Dict!["contextId"].GetString(); + + // Wait for context to expire + await Task.Delay(100); + contextMgr.CleanupExpiredContexts(); + + // Act - Try to use expired context + var result2 = await ReplTools.EvaluateCsharp( + _scriptingService, + contextMgr, + nugetSvc, + "x + 1", + contextId + ); + var json2 = JsonSerializer.Serialize(result2); + var result2Dict = TestJsonContext.DeserializeToDictionary(json2); + + // Assert + Assert.NotNull(result2Dict); + Assert.False(result2Dict["success"].GetBoolean()); + + // Check new error structure (errors array) + Assert.True(result2Dict.TryGetValue("errors", out var errorsElement)); + var errors = errorsElement.EnumerateArray().ToList(); + Assert.NotEmpty(errors); + Assert.Equal("CONTEXT_NOT_FOUND", errors[0].GetProperty("code").GetString()); + } + + [Fact] + [Trait("Feature", "ContextManagement")] + public async Task ValidateCsharp_InvalidContextId_ReturnsProperError() + { + // Arrange + var invalidContextId = "invalid-validation-context-12345"; + var code = "int x = 42;"; + + // Act + var result = await ReplTools.ValidateCsharp( + _scriptingService, + _contextManager, + code, + invalidContextId + ); + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + // Assert + Assert.NotNull(resultDict); + Assert.False(resultDict["isValid"].GetBoolean()); + Assert.Equal("REPL_CONTEXT_INVALID", resultDict["error"].GetString()); + Assert.Contains("not found or expired", resultDict["message"].GetString()); + } + + [Fact] + [Trait("Feature", "ContextManagement")] + public async Task MultipleConcurrentContexts_IsolatedCorrectly() + { + // Arrange + var service = new RoslynScriptingService(); + var contextMgr = new ReplContextManager(); + using var nugetSvc = new NuGetService(); + + // Act - Create two contexts with different variables + var result1 = await ReplTools.EvaluateCsharp( + service, + contextMgr, + nugetSvc, + "int value1 = 100;", + createContext: true + ); + var json1 = JsonSerializer.Serialize(result1); + var result1Dict = TestJsonContext.DeserializeToDictionary(json1); + var context1Id = result1Dict!["contextId"].GetString(); + + var result2 = await ReplTools.EvaluateCsharp( + service, + contextMgr, + nugetSvc, + "int value2 = 200;", + createContext: true + ); + var json2 = JsonSerializer.Serialize(result2); + var result2Dict = TestJsonContext.DeserializeToDictionary(json2); + var context2Id = result2Dict!["contextId"].GetString(); + + // Use variables in their respective contexts + var result1Use = await ReplTools.EvaluateCsharp( + service, + contextMgr, + nugetSvc, + "value1 + 50", + context1Id + ); + var json1Use = JsonSerializer.Serialize(result1Use); + var result1UseDict = TestJsonContext.DeserializeToDictionary(json1Use); + + var result2Use = await ReplTools.EvaluateCsharp( + service, + contextMgr, + nugetSvc, + "value2 + 50", + context2Id + ); + var json2Use = JsonSerializer.Serialize(result2Use); + var result2UseDict = TestJsonContext.DeserializeToDictionary(json2Use); + + // Assert - Both contexts work correctly and independently + Assert.NotNull(result1UseDict); + Assert.True(result1UseDict["success"].GetBoolean()); + Assert.Equal(150, result1UseDict["returnValue"].GetInt32()); + + Assert.NotNull(result2UseDict); + Assert.True(result2UseDict["success"].GetBoolean()); + Assert.Equal(250, result2UseDict["returnValue"].GetInt32()); + } + + [Fact] + [Trait("Feature", "ContextManagement")] + public async Task ContextIsolation_VariablesDoNotLeak() + { + // Arrange + var service = new RoslynScriptingService(); + var contextMgr = new ReplContextManager(); + using var nugetSvc = new NuGetService(); + + // Act - Define variable in context1 + var result1 = await ReplTools.EvaluateCsharp( + service, + contextMgr, + nugetSvc, + "int secretValue = 999;", + createContext: true + ); + var json1 = JsonSerializer.Serialize(result1); + var result1Dict = TestJsonContext.DeserializeToDictionary(json1); + _ = result1Dict!["contextId"].GetString(); // Context 1 created but not used for validation + + // Try to access variable from context2 (should fail - creates new temporary context) + var result2 = await ReplTools.EvaluateCsharp(service, contextMgr, nugetSvc, "secretValue"); + var json2 = JsonSerializer.Serialize(result2); + var result2Dict = TestJsonContext.DeserializeToDictionary(json2); + + // Assert + Assert.NotNull(result2Dict); + Assert.False(result2Dict["success"].GetBoolean()); + Assert.NotEmpty(result2Dict["errors"].EnumerateArray()); + } + + [Fact] + [Trait("Feature", "ContextManagement")] + public async Task ResetRepl_WithSpecificContextId_ResetsOnlyThatContext() + { + // Arrange + var service = new RoslynScriptingService(); + var contextMgr = new ReplContextManager(); + using var nugetSvc = new NuGetService(); + + // Create two contexts + var result1 = await ReplTools.EvaluateCsharp( + service, + contextMgr, + nugetSvc, + "int value1 = 100;", + createContext: true + ); + var json1 = JsonSerializer.Serialize(result1); + var result1Dict = TestJsonContext.DeserializeToDictionary(json1); + var context1Id = result1Dict!["contextId"].GetString(); + + var result2 = await ReplTools.EvaluateCsharp( + service, + contextMgr, + nugetSvc, + "int value2 = 200;", + createContext: true + ); + var json2 = JsonSerializer.Serialize(result2); + var result2Dict = TestJsonContext.DeserializeToDictionary(json2); + var context2Id = result2Dict!["contextId"].GetString(); + + // Act - Reset only context1 + var resetResult = ReplTools.ResetRepl(contextMgr, context1Id); + var resetJson = TestJsonContext.SerializeDynamic(resetResult); + var resetDict = TestJsonContext.DeserializeToDictionary(resetJson); + + // Try to use both contexts + var result1After = await ReplTools.EvaluateCsharp( + service, + contextMgr, + nugetSvc, + "value1", + context1Id + ); + var json1After = JsonSerializer.Serialize(result1After); + var result1AfterDict = JsonSerializer.Deserialize>( + json1After + ); + + var result2After = await ReplTools.EvaluateCsharp( + service, + contextMgr, + nugetSvc, + "value2 + 50", + context2Id + ); + var json2After = JsonSerializer.Serialize(result2After); + var result2AfterDict = JsonSerializer.Deserialize>( + json2After + ); + + // Assert + Assert.NotNull(resetDict); + Assert.True(resetDict["success"].GetBoolean()); + + // Context1 should be invalid + Assert.NotNull(result1AfterDict); + Assert.False(result1AfterDict["success"].GetBoolean()); + + // Check new error structure (errors array) + Assert.True(result1AfterDict.TryGetValue("errors", out var errorsElement)); + var errors = errorsElement.EnumerateArray().ToList(); + Assert.NotEmpty(errors); + Assert.Equal("CONTEXT_NOT_FOUND", errors[0].GetProperty("code").GetString()); + + // Context2 should still work + Assert.NotNull(result2AfterDict); + Assert.True(result2AfterDict["success"].GetBoolean()); + Assert.Equal(250, result2AfterDict["returnValue"].GetInt32()); + } + + [Fact] + [Trait("Feature", "ContextManagement")] + public async Task ResetRepl_WithoutContextId_ResetsAllContexts() + { + // Arrange + var service = new RoslynScriptingService(); + var contextMgr = new ReplContextManager(); + using var nugetSvc = new NuGetService(); + + // Create multiple contexts + var result1 = await ReplTools.EvaluateCsharp( + service, + contextMgr, + nugetSvc, + "int x = 1;", + createContext: true + ); + var json1 = JsonSerializer.Serialize(result1); + var result1Dict = TestJsonContext.DeserializeToDictionary(json1); + var context1Id = result1Dict!["contextId"].GetString(); + + var result2 = await ReplTools.EvaluateCsharp( + service, + contextMgr, + nugetSvc, + "int y = 2;", + createContext: true + ); + var json2 = JsonSerializer.Serialize(result2); + var result2Dict = TestJsonContext.DeserializeToDictionary(json2); + var context2Id = result2Dict!["contextId"].GetString(); + + // Act - Reset all contexts + var resetResult = ReplTools.ResetRepl(contextMgr); + var resetJson = TestJsonContext.SerializeDynamic(resetResult); + var resetDict = TestJsonContext.DeserializeToDictionary(resetJson); + + // Try to use contexts + var result1After = await ReplTools.EvaluateCsharp( + service, + contextMgr, + nugetSvc, + "x", + context1Id + ); + var json1After = JsonSerializer.Serialize(result1After); + var result1AfterDict = JsonSerializer.Deserialize>( + json1After + ); + + var result2After = await ReplTools.EvaluateCsharp( + service, + contextMgr, + nugetSvc, + "y", + context2Id + ); + var json2After = JsonSerializer.Serialize(result2After); + var result2AfterDict = JsonSerializer.Deserialize>( + json2After + ); + + // Assert + Assert.NotNull(resetDict); + Assert.True(resetDict["success"].GetBoolean()); + Assert.Equal(2, resetDict["sessionsCleared"].GetInt32()); + + // Both contexts should be invalid + Assert.False(result1AfterDict!["success"].GetBoolean()); + Assert.False(result2AfterDict!["success"].GetBoolean()); + } +} diff --git a/tests/RoslynStone.Tests/NuGetServiceTests.cs b/tests/RoslynStone.Tests/NuGetServiceTests.cs new file mode 100644 index 0000000000000000000000000000000000000000..7e920cdd8bde09a285e21553e35958f189a283bf --- /dev/null +++ b/tests/RoslynStone.Tests/NuGetServiceTests.cs @@ -0,0 +1,272 @@ +using RoslynStone.Infrastructure.Services; + +namespace RoslynStone.Tests; + +/// +/// Tests for NuGetService +/// +[Trait("Category", "Integration")] +[Trait("Component", "NuGet")] +public class NuGetServiceTests +{ + private readonly NuGetService _service; + + public NuGetServiceTests() + { + _service = new NuGetService(); + } + + [Fact] + [Trait("Feature", "Search")] + public async Task SearchPackagesAsync_ValidQuery_ReturnsResults() + { + // Arrange + var query = "Newtonsoft.Json"; + + // Act + var result = await _service.SearchPackagesAsync(query, 0, 5); + + // Assert + Assert.NotNull(result); + Assert.NotEmpty(result.Packages); + Assert.Contains(result.Packages, p => p.Id.Contains("Newtonsoft.Json")); + } + + [Fact] + [Trait("Feature", "Search")] + public async Task SearchPackagesAsync_WithPagination_RespectsParameters() + { + // Arrange + var query = "logging"; + + // Act + var result = await _service.SearchPackagesAsync(query, 0, 3); + + // Assert + Assert.NotNull(result); + Assert.True(result.Packages.Count <= 3); + } + + [Fact] + [Trait("Feature", "Versions")] + public async Task GetPackageVersionsAsync_ValidPackage_ReturnsVersions() + { + // Arrange + var packageId = "Newtonsoft.Json"; + + // Act + var versions = await _service.GetPackageVersionsAsync(packageId); + + // Assert + Assert.NotNull(versions); + Assert.NotEmpty(versions); + Assert.All(versions, v => Assert.False(string.IsNullOrEmpty(v.Version))); + } + + [Fact] + [Trait("Feature", "Versions")] + public async Task GetPackageVersionsAsync_VersionsSorted_NewestFirst() + { + // Arrange + var packageId = "Newtonsoft.Json"; + + // Act + var versions = await _service.GetPackageVersionsAsync(packageId); + + // Assert + Assert.NotNull(versions); + Assert.NotEmpty(versions); + // Verify first version is newer than last + var firstVersion = NuGet.Versioning.NuGetVersion.Parse(versions.First().Version); + var lastVersion = NuGet.Versioning.NuGetVersion.Parse(versions.Last().Version); + Assert.True(firstVersion >= lastVersion); + } + + [Fact] + [Trait("Feature", "Versions")] + public async Task GetPackageVersionsAsync_InvalidPackage_ReturnsEmpty() + { + // Arrange + var packageId = "ThisPackageDefinitelyDoesNotExist12345XYZ"; + + // Act + var versions = await _service.GetPackageVersionsAsync(packageId); + + // Assert + Assert.NotNull(versions); + Assert.Empty(versions); + } + + [Fact] + [Trait("Feature", "README")] + public async Task GetPackageReadmeAsync_ValidPackage_ReturnsReadme() + { + // Arrange + var packageId = "Newtonsoft.Json"; + + // Act + var readme = await _service.GetPackageReadmeAsync(packageId); + + // Assert - may be null if package doesn't have README + // This is expected behavior, not all packages have READMEs + Assert.True(readme == null || !string.IsNullOrWhiteSpace(readme)); + } + + [Fact] + [Trait("Feature", "Download")] + public async Task DownloadPackageAsync_ValidPackage_ReturnsAssemblyPaths() + { + // Arrange + var packageId = "Newtonsoft.Json"; + var version = "13.0.3"; + + // Act + try + { + var assemblyPaths = await _service.DownloadPackageAsync(packageId, version); + + // Assert + Assert.NotNull(assemblyPaths); + Assert.NotEmpty(assemblyPaths); + Assert.All(assemblyPaths, path => Assert.EndsWith(".dll", path)); + } + catch (InvalidOperationException) + { + // Download may fail in CI environment (e.g., no network or NuGet unavailable). + // Test is allowed to pass in this case. + } + } + + [Fact] + [Trait("Feature", "Download")] + public async Task DownloadPackageAsync_InvalidPackage_ThrowsException() + { + // Arrange + var packageId = "ThisPackageDefinitelyDoesNotExist12345XYZ"; + + // Act & Assert + await Assert.ThrowsAsync(async () => + await _service.DownloadPackageAsync(packageId) + ); + } + + [Fact] + [Trait("Feature", "Download")] + public async Task DownloadPackageAsync_WithSpecificVersion_UsesProvidedVersion() + { + // Arrange - Use a known lightweight package + var packageId = "Newtonsoft.Json"; + var specificVersion = "13.0.1"; // Older version + + // Act + try + { + var result = await _service.DownloadPackageAsync(packageId, specificVersion); + + // Assert + Assert.NotNull(result); + Assert.NotEmpty(result); + } + catch (InvalidOperationException) + { + // Package download may fail in test environment. + // Test passes if method completes without throwing unexpected exceptions. + } + } + + [Fact] + [Trait("Feature", "Download")] + public async Task DownloadPackageAsync_WithoutVersion_UsesLatestStable() + { + // Arrange + var packageId = "Newtonsoft.Json"; + + // Act + try + { + var result = await _service.DownloadPackageAsync(packageId); + + // Assert + Assert.NotNull(result); + // Should prefer stable over prerelease + } + catch (InvalidOperationException) + { + // Package download may fail in test environment. + // Test passes if method completes without throwing unexpected exceptions. + } + } + + [Fact] + [Trait("Feature", "README")] + public async Task GetPackageReadmeAsync_NonExistentPackage_ReturnsNull() + { + // Arrange + var packageId = "ThisPackageDoesNotExist999XYZ"; + + // Act + var readme = await _service.GetPackageReadmeAsync(packageId); + + // Assert + Assert.Null(readme); + } + + [Fact] + [Trait("Feature", "README")] + public async Task GetPackageReadmeAsync_WithSpecificVersion_UsesProvidedVersion() + { + // Arrange + var packageId = "Newtonsoft.Json"; + var version = "13.0.1"; + + // Act + var readme = await _service.GetPackageReadmeAsync(packageId, version); + + // Assert - README may or may not exist, both are valid + Assert.True(readme == null || !string.IsNullOrWhiteSpace(readme)); + } + + [Fact] + [Trait("Feature", "README")] + public async Task GetPackageReadmeAsync_PackageWithoutReadme_ReturnsNull() + { + // Arrange - Use a package that likely doesn't have README + var packageId = "System.Runtime"; + + // Act + var readme = await _service.GetPackageReadmeAsync(packageId); + + // Assert - System packages typically don't have README files + Assert.Null(readme); + } + + [Fact] + [Trait("Feature", "Cancellation")] + public async Task SearchPackagesAsync_WithCancellation_SupportsCancellation() + { + // Arrange + var query = "logging"; + using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5)); + + // Act + var result = await _service.SearchPackagesAsync(query, 0, 5, cts.Token); + + // Assert + Assert.NotNull(result); + } + + [Fact] + [Trait("Feature", "Cancellation")] + public async Task GetPackageVersionsAsync_WithCancellation_SupportsCancellation() + { + // Arrange + var packageId = "Newtonsoft.Json"; + using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5)); + + // Act + var result = await _service.GetPackageVersionsAsync(packageId, cts.Token); + + // Assert + Assert.NotNull(result); + } +} diff --git a/tests/RoslynStone.Tests/ReplContextManagerTests.cs b/tests/RoslynStone.Tests/ReplContextManagerTests.cs new file mode 100644 index 0000000000000000000000000000000000000000..7b33a5448d124d2a74b3cd5156e8b15d8aeae2fc --- /dev/null +++ b/tests/RoslynStone.Tests/ReplContextManagerTests.cs @@ -0,0 +1,321 @@ +using Microsoft.CodeAnalysis.CSharp.Scripting; +using RoslynStone.Infrastructure.Services; + +namespace RoslynStone.Tests; + +/// +/// Tests for ReplContextManager +/// +[Trait("Category", "Unit")] +[Trait("Component", "ContextManagement")] +public class ReplContextManagerTests +{ + [Fact] + [Trait("Feature", "ContextCreation")] + public void CreateContext_ReturnsUniqueId() + { + // Arrange + var manager = new ReplContextManager(); + + // Act + var contextId = manager.CreateContext(); + + // Assert + Assert.NotNull(contextId); + Assert.NotEmpty(contextId); + Assert.True(Guid.TryParse(contextId, out _)); + } + + [Fact] + [Trait("Feature", "ContextCreation")] + public void CreateContext_MultipleCalls_ReturnsDifferentIds() + { + // Arrange + var manager = new ReplContextManager(); + + // Act + var contextId1 = manager.CreateContext(); + var contextId2 = manager.CreateContext(); + + // Assert + Assert.NotEqual(contextId1, contextId2); + } + + [Fact] + [Trait("Feature", "ContextExists")] + public void ContextExists_ExistingContext_ReturnsTrue() + { + // Arrange + var manager = new ReplContextManager(); + var contextId = manager.CreateContext(); + + // Act + var exists = manager.ContextExists(contextId); + + // Assert + Assert.True(exists); + } + + [Fact] + [Trait("Feature", "ContextExists")] + public void ContextExists_NonExistingContext_ReturnsFalse() + { + // Arrange + var manager = new ReplContextManager(); + + // Act + var exists = manager.ContextExists("non-existing-id"); + + // Assert + Assert.False(exists); + } + + [Fact] + [Trait("Feature", "ContextExists")] + public void ContextExists_NullOrEmpty_ReturnsFalse() + { + // Arrange + var manager = new ReplContextManager(); + + // Act & Assert + Assert.False(manager.ContextExists(null!)); + Assert.False(manager.ContextExists(string.Empty)); + Assert.False(manager.ContextExists(" ")); + } + + [Fact] + [Trait("Feature", "ContextState")] + public void GetContextState_NewContext_ReturnsNull() + { + // Arrange + var manager = new ReplContextManager(); + var contextId = manager.CreateContext(); + + // Act + var state = manager.GetContextState(contextId); + + // Assert + Assert.Null(state); + } + + [Fact] + [Trait("Feature", "ContextState")] + public async Task UpdateContextState_ValidContext_UpdatesState() + { + // Arrange + var manager = new ReplContextManager(); + var contextId = manager.CreateContext(); + var scriptState = await CSharpScript.RunAsync("var x = 10;"); + + // Act + manager.UpdateContextState(contextId, scriptState); + var retrievedState = manager.GetContextState(contextId); + + // Assert + Assert.NotNull(retrievedState); + Assert.Equal(scriptState, retrievedState); + } + + [Fact] + [Trait("Feature", "ContextState")] + public async Task UpdateContextState_InvalidContext_ThrowsException() + { + // Arrange + var manager = new ReplContextManager(); + var scriptState = await CSharpScript.RunAsync("var x = 10;"); + + // Act & Assert + Assert.Throws(() => + manager.UpdateContextState("non-existing-id", scriptState) + ); + } + + [Fact] + [Trait("Feature", "ContextState")] + public async Task UpdateContextState_NullContextId_ThrowsException() + { + // Arrange + var manager = new ReplContextManager(); + var scriptState = await CSharpScript.RunAsync("var x = 10;"); + + // Act & Assert + Assert.Throws(() => manager.UpdateContextState(null!, scriptState)); + } + + [Fact] + [Trait("Feature", "ContextRemoval")] + public void RemoveContext_ExistingContext_ReturnsTrue() + { + // Arrange + var manager = new ReplContextManager(); + var contextId = manager.CreateContext(); + + // Act + var removed = manager.RemoveContext(contextId); + + // Assert + Assert.True(removed); + Assert.False(manager.ContextExists(contextId)); + } + + [Fact] + [Trait("Feature", "ContextRemoval")] + public void RemoveContext_NonExistingContext_ReturnsFalse() + { + // Arrange + var manager = new ReplContextManager(); + + // Act + var removed = manager.RemoveContext("non-existing-id"); + + // Assert + Assert.False(removed); + } + + [Fact] + [Trait("Feature", "ContextCleanup")] + public async Task CleanupExpiredContexts_ExpiredContexts_RemovesThem() + { + // Arrange + var shortTimeout = TimeSpan.FromMilliseconds(100); + var manager = new ReplContextManager(contextTimeout: shortTimeout); + var contextId1 = manager.CreateContext(); + var contextId2 = manager.CreateContext(); + + // Wait for contexts to expire + await Task.Delay(150); + + // Act + var removed = manager.CleanupExpiredContexts(); + + // Assert + Assert.Equal(2, removed); + Assert.False(manager.ContextExists(contextId1)); + Assert.False(manager.ContextExists(contextId2)); + } + + [Fact] + [Trait("Feature", "ContextCleanup")] + public void CleanupExpiredContexts_ActiveContexts_DoesNotRemove() + { + // Arrange + var manager = new ReplContextManager(contextTimeout: TimeSpan.FromHours(1)); + var contextId = manager.CreateContext(); + + // Act + var removed = manager.CleanupExpiredContexts(); + + // Assert + Assert.Equal(0, removed); + Assert.True(manager.ContextExists(contextId)); + } + + [Fact] + [Trait("Feature", "ContextList")] + public void GetActiveContexts_MultipleContexts_ReturnsAll() + { + // Arrange + var manager = new ReplContextManager(); + var contextId1 = manager.CreateContext(); + var contextId2 = manager.CreateContext(); + var contextId3 = manager.CreateContext(); + + // Act + var activeContexts = manager.GetActiveContexts(); + + // Assert + Assert.Equal(3, activeContexts.Count); + Assert.Contains(contextId1, activeContexts); + Assert.Contains(contextId2, activeContexts); + Assert.Contains(contextId3, activeContexts); + } + + [Fact] + [Trait("Feature", "ContextList")] + public void GetActiveContexts_NoContexts_ReturnsEmpty() + { + // Arrange + var manager = new ReplContextManager(); + + // Act + var activeContexts = manager.GetActiveContexts(); + + // Assert + Assert.Empty(activeContexts); + } + + [Fact] + [Trait("Feature", "ContextMetadata")] + public void GetContextMetadata_ExistingContext_ReturnsMetadata() + { + // Arrange + var manager = new ReplContextManager(); + var contextId = manager.CreateContext(); + + // Act + var metadata = manager.GetContextMetadata(contextId); + + // Assert + Assert.NotNull(metadata); + Assert.Equal(contextId, metadata.ContextId); + Assert.Equal(0, metadata.ExecutionCount); + Assert.False(metadata.IsInitialized); + } + + [Fact] + [Trait("Feature", "ContextMetadata")] + public async Task GetContextMetadata_AfterExecution_ShowsUpdatedCount() + { + // Arrange + var manager = new ReplContextManager(); + var contextId = manager.CreateContext(); + var scriptState = await CSharpScript.RunAsync("var x = 10;"); + + // Act + manager.UpdateContextState(contextId, scriptState); + var metadata = manager.GetContextMetadata(contextId); + + // Assert + Assert.NotNull(metadata); + Assert.Equal(1, metadata.ExecutionCount); + Assert.True(metadata.IsInitialized); + } + + [Fact] + [Trait("Feature", "ContextMetadata")] + public void GetContextMetadata_NonExistingContext_ReturnsNull() + { + // Arrange + var manager = new ReplContextManager(); + + // Act + var metadata = manager.GetContextMetadata("non-existing-id"); + + // Assert + Assert.Null(metadata); + } + + [Fact] + [Trait("Feature", "ThreadSafety")] + public void CreateContext_ConcurrentCalls_AllSucceed() + { + // Arrange + var manager = new ReplContextManager(); + var contextIds = new System.Collections.Concurrent.ConcurrentBag(); + + // Act + Parallel.For( + 0, + 100, + _ => + { + var contextId = manager.CreateContext(); + contextIds.Add(contextId); + } + ); + + // Assert + Assert.Equal(100, contextIds.Count); + Assert.Equal(100, contextIds.Distinct().Count()); // All unique + } +} diff --git a/tests/RoslynStone.Tests/ReplToolsContextControlTests.cs b/tests/RoslynStone.Tests/ReplToolsContextControlTests.cs new file mode 100644 index 0000000000000000000000000000000000000000..2cf048c33ab6327962651f0e73c4aefb951b1a11 --- /dev/null +++ b/tests/RoslynStone.Tests/ReplToolsContextControlTests.cs @@ -0,0 +1,393 @@ +using System.Text.Json; +using RoslynStone.Core.Models; +using RoslynStone.Infrastructure.Services; +using RoslynStone.Infrastructure.Tools; +using RoslynStone.Tests.Serialization; + +namespace RoslynStone.Tests; + +/// +/// Tests for REPL tools context control parameter functionality +/// +[Trait("Category", "Unit")] +[Trait("Component", "REPL")] +public class ReplToolsContextControlTests : IDisposable +{ + private readonly RoslynScriptingService _scriptingService; + private readonly IReplContextManager _contextManager; + private readonly NuGetService _nugetService; + + public ReplToolsContextControlTests() + { + _scriptingService = new RoslynScriptingService(); + _contextManager = new ReplContextManager(); + _nugetService = new NuGetService(); + } + + public void Dispose() + { + _nugetService.Dispose(); + } + + [Fact] + [Trait("Feature", "ContextControl")] + public async Task EvaluateCsharp_CreateContextFalse_DoesNotReturnContextId() + { + // Arrange + var code = "1 + 1"; + + // Act + var result = await ReplTools.EvaluateCsharp( + _scriptingService, + _contextManager, + _nugetService, + code, + createContext: false + ); + + // Serialize to inspect result + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + // Assert + Assert.NotNull(resultDict); + Assert.True(resultDict["success"].GetBoolean()); + Assert.Equal(2, resultDict["returnValue"].GetInt32()); + Assert.False( + resultDict.TryGetValue("contextId", out var contextIdElem) + && contextIdElem.ValueKind != JsonValueKind.Null + ); + } + + [Fact] + [Trait("Feature", "ContextControl")] + public async Task EvaluateCsharp_CreateContextTrue_ReturnsContextId() + { + // Arrange + var code = "var x = 42;"; + + // Act + var result = await ReplTools.EvaluateCsharp( + _scriptingService, + _contextManager, + _nugetService, + code, + createContext: true + ); + + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + // Assert + Assert.NotNull(resultDict); + Assert.True(resultDict["success"].GetBoolean()); + Assert.True(resultDict.TryGetValue("contextId", out var contextIdElement)); + Assert.NotNull(contextIdElement.GetString()); + Assert.True(Guid.TryParse(contextIdElement.GetString(), out _)); + } + + [Fact] + [Trait("Feature", "ContextControl")] + public async Task EvaluateCsharp_DefaultBehavior_DoesNotReturnContextId() + { + // Arrange + var code = "1 + 1"; + + // Act - Call without createContext parameter (should default to false) + var result = await ReplTools.EvaluateCsharp( + _scriptingService, + _contextManager, + _nugetService, + code + ); + + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + // Assert + Assert.NotNull(resultDict); + Assert.True(resultDict["success"].GetBoolean()); + Assert.False( + resultDict.TryGetValue("contextId", out var contextIdElem) + && contextIdElem.ValueKind != JsonValueKind.Null + ); + } + + [Fact] + [Trait("Feature", "ContextControl")] + public async Task EvaluateCsharp_WithContextId_IgnoresCreateContextParameter() + { + // Arrange - First create a context + var createResult = await ReplTools.EvaluateCsharp( + _scriptingService, + _contextManager, + _nugetService, + "var x = 10;", + createContext: true + ); + var json1 = TestJsonContext.SerializeDynamic(createResult); + var dict1 = TestJsonContext.DeserializeToDictionary(json1); + var contextId = dict1!["contextId"].GetString(); + + // Act - Continue with the context (createContext should be ignored) + var result = await ReplTools.EvaluateCsharp( + _scriptingService, + _contextManager, + _nugetService, + "x * 2", + contextId: contextId, + createContext: false // This should be ignored since contextId is provided + ); + + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + // Assert + Assert.NotNull(resultDict); + Assert.True(resultDict["success"].GetBoolean()); + Assert.Equal(20, resultDict["returnValue"].GetInt32()); + Assert.Equal(contextId, resultDict["contextId"].GetString()); + } + + [Fact] + [Trait("Feature", "NuGetIntegration")] + public async Task EvaluateCsharp_WithNuGetPackages_LoadsPackagesBeforeExecution() + { + // Arrange + var code = + @" +using Newtonsoft.Json; +var obj = new { Name = ""Test"", Value = 42 }; +JsonConvert.SerializeObject(obj) +"; + var packages = new[] { new NuGetPackageSpec { PackageName = "Newtonsoft.Json" } }; + + // Act + var result = await ReplTools.EvaluateCsharp( + _scriptingService, + _contextManager, + _nugetService, + code, + nugetPackages: packages, + createContext: false + ); + + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + // Assert + Assert.NotNull(resultDict); + Assert.True(resultDict["success"].GetBoolean()); + Assert.Contains("Test", resultDict["returnValue"].GetString()); + Assert.Contains("42", resultDict["returnValue"].GetString()); + } + + [Fact] + [Trait("Feature", "NuGetIntegration")] + public async Task EvaluateCsharp_WithNuGetPackagesAndVersion_LoadsSpecificVersion() + { + // Arrange + var code = + @" +using Newtonsoft.Json; +JsonConvert.SerializeObject(new { Test = 1 }) +"; + var packages = new[] + { + new NuGetPackageSpec { PackageName = "Newtonsoft.Json", Version = "13.0.1" }, + }; + + // Act + var result = await ReplTools.EvaluateCsharp( + _scriptingService, + _contextManager, + _nugetService, + code, + nugetPackages: packages, + createContext: false + ); + + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + // Assert + Assert.NotNull(resultDict); + Assert.True(resultDict["success"].GetBoolean()); + Assert.Contains("Test", resultDict["returnValue"].GetString()); + } + + [Fact] + [Trait("Feature", "NuGetIntegration")] + public async Task EvaluateCsharp_WithNullNuGetPackages_ExecutesWithoutPackageLoading() + { + // Arrange + var code = "1 + 1"; + + // Act + var result = await ReplTools.EvaluateCsharp( + _scriptingService, + _contextManager, + _nugetService, + code, + nugetPackages: null, + createContext: false + ); + + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + // Assert + Assert.NotNull(resultDict); + Assert.True(resultDict["success"].GetBoolean()); + Assert.Equal(2, resultDict["returnValue"].GetInt32()); + } + + [Fact] + [Trait("Feature", "NuGetIntegration")] + public async Task EvaluateCsharp_WithEmptyNuGetPackages_ExecutesWithoutPackageLoading() + { + // Arrange + var code = "1 + 1"; + + // Act + var result = await ReplTools.EvaluateCsharp( + _scriptingService, + _contextManager, + _nugetService, + code, + nugetPackages: Array.Empty(), + createContext: false + ); + + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + // Assert + Assert.NotNull(resultDict); + Assert.True(resultDict["success"].GetBoolean()); + Assert.Equal(2, resultDict["returnValue"].GetInt32()); + } + + [Fact] + [Trait("Feature", "ContextControl")] + public async Task ValidateCsharp_CreateContextFalse_ReturnsValidationWithoutContextId() + { + // Arrange & Act - Execute code in temporary context + await ReplTools.EvaluateCsharp( + _scriptingService, + _contextManager, + _nugetService, + "var x = 10;", + createContext: false + ); + + // Try to access variable from previous execution + var result2 = await ReplTools.EvaluateCsharp( + _scriptingService, + _contextManager, + _nugetService, + "x * 2", + createContext: false + ); + + var json = JsonSerializer.Serialize(result2); + var resultDict = JsonSerializer.Deserialize>(json); + + // Assert - Should fail because x is not defined + Assert.NotNull(resultDict); + Assert.False(resultDict["success"].GetBoolean()); + Assert.True(resultDict["errors"].GetArrayLength() > 0); + } + + [Fact] + [Trait("Feature", "NuGetIntegration")] + public async Task EvaluateCsharp_WithMultiplePackages_LoadsAllPackages() + { + // Arrange + var code = + @" +using Newtonsoft.Json; +var data = new { X = 10, Y = 20 }; +JsonConvert.SerializeObject(data) +"; + var packages = new[] + { + new NuGetPackageSpec { PackageName = "Newtonsoft.Json" }, + new NuGetPackageSpec { PackageName = "System.Text.Json" }, + }; + + // Act + var result = await ReplTools.EvaluateCsharp( + _scriptingService, + _contextManager, + _nugetService, + code, + nugetPackages: packages, + createContext: false + ); + + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + // Assert + Assert.NotNull(resultDict); + Assert.True(resultDict["success"].GetBoolean()); + Assert.Contains("10", resultDict["returnValue"].GetString()); + } + + [Fact] + [Trait("Feature", "NuGetIntegration")] + public async Task EvaluateCsharp_WithStatefulContextAndPackages_PackagesPersistInContext() + { + // Arrange - Load package in stateful context + var packages = new[] { new NuGetPackageSpec { PackageName = "Newtonsoft.Json" } }; + + var result1 = await ReplTools.EvaluateCsharp( + _scriptingService, + _contextManager, + _nugetService, + "using Newtonsoft.Json;", + nugetPackages: packages, + createContext: true + ); + + var json1 = JsonSerializer.Serialize(result1); + var dict1 = JsonSerializer.Deserialize>(json1); + var contextId = dict1!["contextId"].GetString(); + + // Act - Use package in the same context without loading again + var result2 = await ReplTools.EvaluateCsharp( + _scriptingService, + _contextManager, + _nugetService, + @"JsonConvert.SerializeObject(new { Test = 1 })", + contextId: contextId + ); + + var json2 = JsonSerializer.Serialize(result2); + var resultDict = JsonSerializer.Deserialize>(json2); + + // Assert + Assert.NotNull(resultDict); + Assert.True(resultDict["success"].GetBoolean()); + Assert.Contains("Test", resultDict["returnValue"].GetString()); + } + + [Fact] + [Trait("Feature", "ContextControl")] + public async Task ValidateCsharp_WithoutContext_ValidatesCode() + { + // Arrange + var code = "int x = 10; x * 2"; + + // Act + var result = await ReplTools.ValidateCsharp(_scriptingService, _contextManager, code); + + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + // Assert + Assert.NotNull(resultDict); + Assert.True(resultDict["isValid"].GetBoolean()); + } +} diff --git a/tests/RoslynStone.Tests/ResourceEquivalentToolsTests.cs b/tests/RoslynStone.Tests/ResourceEquivalentToolsTests.cs new file mode 100644 index 0000000000000000000000000000000000000000..6b6705046a26461887a832be4b2806aa858a9081 --- /dev/null +++ b/tests/RoslynStone.Tests/ResourceEquivalentToolsTests.cs @@ -0,0 +1,314 @@ +using System.Text.Json; +using RoslynStone.Infrastructure.Services; +using RoslynStone.Infrastructure.Tools; +using RoslynStone.Tests.Serialization; + +namespace RoslynStone.Tests; + +/// +/// Tests for MCP Tools that provide equivalent functionality to Resources +/// +[Trait("Category", "Unit")] +[Trait("Component", "Tools")] +public class ResourceEquivalentToolsTests +{ + private readonly RoslynScriptingService _scriptingService; + private readonly DocumentationService _documentationService; + private readonly NuGetService _nugetService; + private readonly IReplContextManager _contextManager; + + public ResourceEquivalentToolsTests() + { + _scriptingService = new RoslynScriptingService(); + _documentationService = new DocumentationService(); + _nugetService = new NuGetService(); + _contextManager = new ReplContextManager(); + } + + #region Documentation Tools Tests + + [Fact] + [Trait("Feature", "Documentation")] + public async Task GetDocumentation_ValidSymbol_ReturnsDocumentation() + { + // Arrange + var symbolName = "System.String"; + + // Act + var result = await DocumentationTools.GetDocumentation(_documentationService, symbolName); + + // Assert + Assert.NotNull(result); + var json = TestJsonContext.SerializeDynamic(result); + var dict = TestJsonContext.DeserializeToDictionary(json); + Assert.NotNull(dict); + } + + [Fact] + [Trait("Feature", "Documentation")] + public async Task GetDocumentation_InvalidSymbol_ReturnsNotFound() + { + // Arrange + var symbolName = "NonExistent.Type.Name"; + + // Act + var result = await DocumentationTools.GetDocumentation(_documentationService, symbolName); + + // Assert + Assert.NotNull(result); + var json = TestJsonContext.SerializeDynamic(result); + var dict = TestJsonContext.DeserializeToDictionary(json); + Assert.NotNull(dict); + Assert.True(dict.TryGetValue("found", out var foundElement)); + Assert.False(foundElement.GetBoolean()); + } + + [Fact] + [Trait("Feature", "Documentation")] + public async Task GetDocumentation_WithPackageId_ParsesCorrectly() + { + // Arrange + var symbolName = "Newtonsoft.Json.JsonConvert"; + var packageId = "Newtonsoft.Json"; + + // Act + var result = await DocumentationTools.GetDocumentation( + _documentationService, + symbolName, + packageId + ); + + // Assert + Assert.NotNull(result); + // Package may or may not be available, but should not throw + } + + #endregion + + #region NuGet Tools Tests + + [Fact] + [Trait("Feature", "NuGet")] + public async Task SearchNuGetPackages_ValidQuery_ReturnsResults() + { + // Arrange + var query = "Newtonsoft.Json"; + + // Act + var result = await NuGetTools.SearchNuGetPackages(_nugetService, query, 0, 5); + + // Assert + Assert.NotNull(result); + var json = TestJsonContext.SerializeDynamic(result); + var dict = TestJsonContext.DeserializeToDictionary(json); + Assert.NotNull(dict); + Assert.True(dict.TryGetValue("packages", out _)); + Assert.True(dict.TryGetValue("totalCount", out var totalCountElement)); + Assert.True(totalCountElement.GetInt32() > 0); + } + + [Fact] + [Trait("Feature", "NuGet")] + public async Task SearchNuGetPackages_WithDefaultPagination_UsesDefaults() + { + // Arrange + var query = "json"; + + // Act + var result = await NuGetTools.SearchNuGetPackages(_nugetService, query); + + // Assert + Assert.NotNull(result); + var json = TestJsonContext.SerializeDynamic(result); + var dict = TestJsonContext.DeserializeToDictionary(json); + Assert.NotNull(dict); + Assert.True(dict.TryGetValue("skip", out var skipElement)); + Assert.Equal(0, skipElement.GetInt32()); + Assert.True(dict.TryGetValue("take", out var takeElement)); + Assert.Equal(20, takeElement.GetInt32()); + } + + [Fact] + [Trait("Feature", "NuGet")] + public async Task SearchNuGetPackages_TakeExceedsMax_ClampsTo100() + { + // Arrange + var query = "json"; + + // Act + var result = await NuGetTools.SearchNuGetPackages(_nugetService, query, 0, 200); + + // Assert + Assert.NotNull(result); + var json = TestJsonContext.SerializeDynamic(result); + var dict = TestJsonContext.DeserializeToDictionary(json); + Assert.NotNull(dict); + Assert.True(dict.TryGetValue("take", out var takeElement)); + Assert.Equal(100, takeElement.GetInt32()); + } + + [Fact] + [Trait("Feature", "NuGet")] + public async Task GetNuGetPackageVersions_ValidPackage_ReturnsVersions() + { + // Arrange + var packageId = "Newtonsoft.Json"; + + // Act + var result = await NuGetTools.GetNuGetPackageVersions(_nugetService, packageId); + + // Assert + Assert.NotNull(result); + var json = TestJsonContext.SerializeDynamic(result); + var dict = TestJsonContext.DeserializeToDictionary(json); + Assert.NotNull(dict); + Assert.True(dict.TryGetValue("found", out var foundElement)); + Assert.True(foundElement.GetBoolean()); + Assert.True(dict.TryGetValue("packageId", out var packageIdElement)); + Assert.Equal(packageId, packageIdElement.GetString()); + Assert.True(dict.TryGetValue("versions", out var versionsElement)); + Assert.True(versionsElement.GetArrayLength() > 0); + Assert.True(dict.TryGetValue("totalCount", out var totalCountElement)); + Assert.True(totalCountElement.GetInt32() > 0); + } + + [Fact] + [Trait("Feature", "NuGet")] + public async Task GetNuGetPackageVersions_InvalidPackage_ReturnsNotFound() + { + // Arrange + var packageId = "NonExistentPackage12345XYZ"; + + // Act + var result = await NuGetTools.GetNuGetPackageVersions(_nugetService, packageId); + + // Assert + Assert.NotNull(result); + var json = TestJsonContext.SerializeDynamic(result); + var dict = TestJsonContext.DeserializeToDictionary(json); + Assert.NotNull(dict); + // The service returns an empty list for non-existent packages + // Our tool should still return found=true but with 0 versions + Assert.True(dict.TryGetValue("found", out var foundElement)); + Assert.True(foundElement.GetBoolean()); + Assert.True(dict.TryGetValue("totalCount", out var totalCountElement)); + Assert.Equal(0, totalCountElement.GetInt32()); + } + + [Fact] + [Trait("Feature", "NuGet")] + public async Task GetNuGetPackageReadme_ValidPackage_ReturnsReadme() + { + // Arrange + var packageId = "Newtonsoft.Json"; + + // Act + var result = await NuGetTools.GetNuGetPackageReadme(_nugetService, packageId); + + // Assert + Assert.NotNull(result); + var json = TestJsonContext.SerializeDynamic(result); + var dict = TestJsonContext.DeserializeToDictionary(json); + Assert.NotNull(dict); + Assert.True(dict.TryGetValue("packageId", out var packageIdElement)); + Assert.Equal(packageId, packageIdElement.GetString()); + Assert.True(dict.TryGetValue("content", out _)); + } + + [Fact] + [Trait("Feature", "NuGet")] + public async Task GetNuGetPackageReadme_WithVersion_ReturnsVersionedReadme() + { + // Arrange + var packageId = "Newtonsoft.Json"; + var version = "13.0.3"; + + // Act + var result = await NuGetTools.GetNuGetPackageReadme(_nugetService, packageId, version); + + // Assert + Assert.NotNull(result); + var json = TestJsonContext.SerializeDynamic(result); + var dict = TestJsonContext.DeserializeToDictionary(json); + Assert.NotNull(dict); + Assert.True(dict.TryGetValue("packageId", out var packageIdElement)); + Assert.Equal(packageId, packageIdElement.GetString()); + Assert.True(dict.TryGetValue("version", out var versionElement)); + Assert.Equal(version, versionElement.GetString()); + } + + #endregion + + #region REPL Tools Tests + + [Fact] + [Trait("Feature", "REPL")] + public void GetReplInfo_WithoutContext_ReturnsGeneralInfo() + { + // Act + var result = ReplTools.GetReplInfo(_scriptingService, _contextManager); + + // Assert + Assert.NotNull(result); + var json = TestJsonContext.SerializeDynamic(result); + var dict = TestJsonContext.DeserializeToDictionary(json); + Assert.NotNull(dict); + Assert.True(dict.TryGetValue("frameworkVersion", out _)); + Assert.True(dict.TryGetValue("language", out _)); + Assert.True(dict.TryGetValue("capabilities", out _)); + Assert.True(dict.TryGetValue("defaultImports", out _)); + Assert.True(dict.TryGetValue("isSessionSpecific", out var isSessionSpecificElement)); + Assert.False(isSessionSpecificElement.GetBoolean()); + } + + [Fact] + [Trait("Feature", "REPL")] + public void GetReplInfo_WithValidContext_ReturnsSessionInfo() + { + // Arrange + var contextId = _contextManager.CreateContext(); + + // Act + var result = ReplTools.GetReplInfo(_scriptingService, _contextManager, contextId); + + // Assert + Assert.NotNull(result); + var json = TestJsonContext.SerializeDynamic(result); + var dict = TestJsonContext.DeserializeToDictionary(json); + Assert.NotNull(dict); + Assert.True(dict.TryGetValue("contextId", out var contextIdElement)); + Assert.Equal(contextId, contextIdElement.GetString()); + Assert.True(dict.TryGetValue("isSessionSpecific", out var isSessionSpecificElement)); + Assert.True(isSessionSpecificElement.GetBoolean()); + Assert.True(dict.TryGetValue("sessionMetadata", out _)); + + // Cleanup + _contextManager.RemoveContext(contextId); + } + + [Fact] + [Trait("Feature", "REPL")] + public void GetReplInfo_WithInvalidContext_ReturnsGeneralInfo() + { + // Arrange + var contextId = "non-existent-context"; + + // Act + var result = ReplTools.GetReplInfo(_scriptingService, _contextManager, contextId); + + // Assert + Assert.NotNull(result); + var json = TestJsonContext.SerializeDynamic(result); + var dict = TestJsonContext.DeserializeToDictionary(json); + Assert.NotNull(dict); + Assert.True(dict.TryGetValue("contextId", out var contextIdElement)); + Assert.Equal(contextId, contextIdElement.GetString()); + Assert.True(dict.TryGetValue("isSessionSpecific", out var isSessionSpecificElement)); + Assert.True(isSessionSpecificElement.GetBoolean()); + // sessionMetadata should be null for invalid context + Assert.True(dict.TryGetValue("sessionMetadata", out var sessionMetadataElement)); + Assert.Equal(JsonValueKind.Null, sessionMetadataElement.ValueKind); + } + + #endregion +} diff --git a/tests/RoslynStone.Tests/ResourceTests.cs b/tests/RoslynStone.Tests/ResourceTests.cs new file mode 100644 index 0000000000000000000000000000000000000000..a3f99344e848d5d1e70cc7c3ad1db7eefb11e163 --- /dev/null +++ b/tests/RoslynStone.Tests/ResourceTests.cs @@ -0,0 +1,474 @@ +// ReSharper disable RedundantUsingDirective - Required for FormatterServices +using System.Runtime.Serialization; +using System.Text.Json; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using RoslynStone.Infrastructure.Resources; +using RoslynStone.Infrastructure.Services; +using RoslynStone.Tests.Serialization; + +namespace RoslynStone.Tests; + +/// +/// Tests for MCP Resources +/// +[Trait("Category", "Unit")] +[Trait("Component", "Resources")] +public class ResourceTests +{ + private readonly RoslynScriptingService _scriptingService; + private readonly DocumentationService _documentationService; + private readonly NuGetService _nugetService; + private readonly IReplContextManager _contextManager; + + public ResourceTests() + { + _scriptingService = new RoslynScriptingService(); + _documentationService = new DocumentationService(); + _nugetService = new NuGetService(); + _contextManager = new ReplContextManager(); + } + + private static RequestContext CreateRequestContext(string uri) + { + // Try creating via public constructor. If the library enforces non-null arguments, fall back to uninitialized object. + try + { + var context = new RequestContext(null!, null!); + context + .GetType() + .GetProperty("Params") + ?.SetValue(context, new ReadResourceRequestParams { Uri = uri }); + return context; + } + catch + { + // FormatterServices.GetUninitializedObject is obsolete but acceptable here for test isolation; use with pragma to avoid errors. +#pragma warning disable SYSLIB0050 + var contextType = typeof(RequestContext); + var context = + (RequestContext) + FormatterServices.GetUninitializedObject(contextType); + var param = new ReadResourceRequestParams { Uri = uri }; + contextType.GetProperty("Params")?.SetValue(context, param); + return context; +#pragma warning restore SYSLIB0050 + } + } + + [Fact] + [Trait("Feature", "Documentation")] + public async Task DocumentationResource_GetDocumentation_ValidUri_ReturnsDocumentation() + { + // Arrange + var uri = "doc://System.String"; + var requestContext = CreateRequestContext(uri); + + // Act + var id = uri.StartsWith("doc://") ? uri[6..] : uri; + var result = await DocumentationResource.GetDocumentation( + _documentationService, + requestContext, + id + ); + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + // Assert + Assert.NotNull(resultDict); + Assert.True(resultDict.TryGetValue("uri", out var uriElement)); + Assert.Equal(uri, uriElement.GetString()); + Assert.True(resultDict.TryGetValue("mimeType", out var mimeTypeElement)); + Assert.Equal("application/json", mimeTypeElement.GetString()); + } + + [Fact] + [Trait("Feature", "Documentation")] + public async Task DocumentationResource_GetDocumentation_WithoutPrefix_ReturnsDocumentation() + { + // Arrange + var uri = "System.String"; + var requestContext = CreateRequestContext(uri); + + // Act + var id = uri.StartsWith("doc://") ? uri[6..] : uri; + var result = await DocumentationResource.GetDocumentation( + _documentationService, + requestContext, + id + ); + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + // Assert + Assert.NotNull(resultDict); + Assert.True(resultDict.TryGetValue("uri", out _)); + } + + [Fact] + [Trait("Feature", "Documentation")] + public async Task DocumentationResource_GetDocumentation_InvalidSymbol_ReturnsNotFound() + { + // Arrange + var uri = "doc://NonExistent.Type.Name"; + var requestContext = CreateRequestContext(uri); + + // Act + var id = uri.StartsWith("doc://") ? uri[6..] : uri; + var result = await DocumentationResource.GetDocumentation( + _documentationService, + requestContext, + id + ); + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + // Assert — either a structured response with a 'found' boolean or a TextResourceContents with a message + Assert.NotNull(resultDict); + if (resultDict.TryGetValue("found", out var foundElement)) + { + Assert.False(foundElement.GetBoolean()); + } + else + { + Assert.True(resultDict.TryGetValue("text", out var textElem)); + var text = textElem.GetString() ?? string.Empty; + Assert.Contains("Documentation not found", text, StringComparison.OrdinalIgnoreCase); + } + } + + [Fact] + [Trait("Feature", "Documentation")] + public async Task DocumentationResource_GetDocumentation_PackageUriFormat_ParsesCorrectly() + { + // Arrange + var uri = "doc://Newtonsoft.Json@Newtonsoft.Json.JsonConvert"; + var requestContext = CreateRequestContext(uri); + + // Act + var id = uri.StartsWith("doc://") ? uri[6..] : uri; + var result = await DocumentationResource.GetDocumentation( + _documentationService, + requestContext, + id + ); + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + // Assert — check URI and either a 'found' flag or a textual message + Assert.NotNull(resultDict); + Assert.True(resultDict.TryGetValue("uri", out var uriElement)); + Assert.Equal(uri, uriElement.GetString()); + if (resultDict.TryGetValue("found", out var _)) + { + Assert.True(true); + } + else + { + Assert.True(resultDict.TryGetValue("text", out var textElem)); + var text = textElem.GetString() ?? string.Empty; + Assert.True(text.Length > 0); + } + } + + [Fact] + [Trait("Feature", "NuGet")] + public async Task NuGetSearchResource_SearchPackages_ValidQuery_ReturnsResults() + { + // Arrange + var uri = "nuget://search?q=Newtonsoft.Json&skip=0&take=5"; + var requestContext = CreateRequestContext(uri); + + // Act + var result = await NuGetSearchResource.SearchPackages( + _nugetService, + requestContext, + "Newtonsoft.Json", + 0, + 5 + ); + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + // Assert — prefer structured properties; fallback to parsing the text content + Assert.NotNull(resultDict); + Assert.True(resultDict.TryGetValue("uri", out var uriElement)); + Assert.Equal(uri, uriElement.GetString()); + if (resultDict.TryGetValue("totalCount", out var totalCountElement)) + { + Assert.True(totalCountElement.GetInt32() > 0); + } + else + { + Assert.True(resultDict.TryGetValue("text", out var textElem)); + var text = textElem.GetString() ?? string.Empty; + Assert.Contains("Search Results for", text); + Assert.Contains("Total Packages Found", text); + } + } + + [Fact] + [Trait("Feature", "NuGet")] + public async Task NuGetSearchResource_SearchPackages_WithoutQueryParams_UsesDefaults() + { + // Arrange + var uri = "nuget://search?q=json"; + var requestContext = CreateRequestContext(uri); + + // Act + // ReSharper disable RedundantArgumentDefaultValue - Explicit for test clarity + var result = await NuGetSearchResource.SearchPackages( + _nugetService, + requestContext, + "json", + null, + null + ); + // ReSharper restore RedundantArgumentDefaultValue + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + // Assert — if structured response, check skip/take; otherwise verify text contains query and defaults implied + Assert.NotNull(resultDict); + if ( + resultDict.TryGetValue("skip", out var skipElem) + && resultDict.TryGetValue("take", out var takeElem) + ) + { + Assert.Equal(0, skipElem.GetInt32()); + Assert.Equal(20, takeElem.GetInt32()); + } + else + { + Assert.True(resultDict.TryGetValue("text", out var textElem)); + var text = textElem.GetString() ?? string.Empty; + Assert.Contains("Search Results for 'json'", text); + } + } + + [Fact] + [Trait("Feature", "NuGet")] + public async Task NuGetPackageResource_GetPackageVersions_ValidPackage_ReturnsVersions() + { + // Arrange + var uri = "nuget://packages/Newtonsoft.Json/versions"; + var requestContext = CreateRequestContext(uri); + + // Act + var path = uri.StartsWith("nuget://") ? uri.Substring("nuget://".Length) : uri; + var parts = path.Split('/'); + var id = parts.Length > 1 ? parts[1] : string.Empty; // 'packages/{id}/versions' + var result = await NuGetPackageResource.GetPackageVersions( + _nugetService, + requestContext, + id + ); + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + // Assert — prefer structured response; fallback to parsing text + Assert.NotNull(resultDict); + if (resultDict.TryGetValue("found", out var foundElement)) + { + Assert.True(foundElement.GetBoolean()); + Assert.True(resultDict.TryGetValue("packageId", out var packageIdElement)); + Assert.Equal("Newtonsoft.Json", packageIdElement.GetString()); + Assert.True(resultDict.TryGetValue("versions", out var versionsElement)); + Assert.True(versionsElement.GetArrayLength() > 0); + } + else + { + Assert.True(resultDict.TryGetValue("text", out var textElem)); + var text = textElem.GetString() ?? string.Empty; + Assert.Contains("Total Versions", text); + Assert.Contains("Package ID: Newtonsoft.Json", text); + } + } + + [Fact] + [Trait("Feature", "NuGet")] + public async Task NuGetPackageResource_GetPackageVersions_InvalidUri_ReturnsNotFound() + { + // Arrange + var uri = "nuget://packages//versions"; + var requestContext = CreateRequestContext(uri); + + // Act + var path = uri.StartsWith("nuget://") ? uri.Substring("nuget://".Length) : uri; + var parts = path.Split('/'); + var id = parts.Length > 1 ? parts[1] : string.Empty; // may be empty + var result = await NuGetPackageResource.GetPackageVersions( + _nugetService, + requestContext, + id + ); + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + // Assert — structured fallback, otherwise check textual message + Assert.NotNull(resultDict); + if (resultDict.TryGetValue("found", out var foundElement)) + { + Assert.False(foundElement.GetBoolean()); + } + else + { + Assert.True(resultDict.TryGetValue("text", out var textElem)); + var text = textElem.GetString() ?? string.Empty; + Assert.True( + text.Contains("Package not found", StringComparison.OrdinalIgnoreCase) + || text.Contains("Invalid package ID", StringComparison.OrdinalIgnoreCase) + ); + } + } + + [Fact] + [Trait("Feature", "NuGet")] + public async Task NuGetPackageResource_GetPackageReadme_ValidPackage_ReturnsReadme() + { + // Arrange + var uri = "nuget://packages/Newtonsoft.Json/readme"; + var requestContext = CreateRequestContext(uri); + + // Act + var id = + uri.Split('/', StringSplitOptions.RemoveEmptyEntries).Skip(1).FirstOrDefault() + ?? string.Empty; // 'packages/{id}/readme' + var result = await NuGetPackageResource.GetPackageReadme(_nugetService, requestContext, id); + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + // Assert + Assert.NotNull(resultDict); + Assert.True(resultDict.TryGetValue("uri", out _)); + Assert.True(resultDict.TryGetValue("mimeType", out var mimeTypeElement)); + Assert.Equal("text/markdown", mimeTypeElement.GetString()); + // README structure should be present (content key might be present) + } + + [Fact] + [Trait("Feature", "NuGet")] + public async Task NuGetPackageResource_GetPackageReadme_WithVersion_ReturnsVersionedReadme() + { + // Arrange + var uri = "nuget://packages/Newtonsoft.Json/readme?version=13.0.3"; + var requestContext = CreateRequestContext(uri); + + // Act + var id = + uri.Split('/', StringSplitOptions.RemoveEmptyEntries).Skip(1).FirstOrDefault() + ?? string.Empty; + // Extract version from query if present + var version = uri.Contains("version=") + ? uri.Split("version=").Last().Split('&').First() + : null; + var result = await NuGetPackageResource.GetPackageReadme( + _nugetService, + requestContext, + id, + version + ); + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + // Assert + Assert.NotNull(resultDict); + Assert.True(resultDict.TryGetValue("uri", out _)); + Assert.True(resultDict.TryGetValue("mimeType", out _)); + // Version should be present in the response + } + + [Fact] + [Trait("Feature", "REPL")] + public void ReplStateResource_GetReplState_ReturnsState() + { + // Arrange + var uri = "repl://state"; + var requestContext = CreateRequestContext(uri); + + // Act + var result = ReplStateResource.GetReplState( + _scriptingService, + _contextManager, + requestContext + ); + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + // Assert — check structured results or fallback to text content + Assert.NotNull(resultDict); + Assert.True(resultDict.TryGetValue("uri", out var uriElement)); + Assert.Equal(uri, uriElement.GetString()); + if (resultDict.TryGetValue("frameworkVersion", out _)) + { + Assert.True(true); + } + else + { + Assert.True(resultDict.TryGetValue("text", out var textElem)); + var text = textElem.GetString() ?? string.Empty; + Assert.Contains("Framework Version", text); + Assert.Contains("Language", text); + Assert.Contains("Default Imports", text); + } + } + + [Fact] + [Trait("Feature", "REPL")] + public void ReplStateResource_GetReplState_AlternativeUri_ReturnsState() + { + // Arrange + var uri = "repl://info"; + var requestContext = CreateRequestContext(uri); + + // Act + var result = ReplStateResource.GetReplState( + _scriptingService, + _contextManager, + requestContext + ); + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + // Assert + Assert.NotNull(resultDict); + Assert.True(resultDict.TryGetValue("uri", out var uriElement)); + Assert.Equal(uri, uriElement.GetString()); + } + + [Fact] + [Trait("Feature", "REPL")] + public void ReplStateResource_GetReplState_SessionSpecificUri_ReturnsSessionState() + { + // Arrange + var uri = "repl://sessions/test-context-123/state"; + var requestContext = CreateRequestContext(uri); + + // Act + var result = ReplStateResource.GetReplState( + _scriptingService, + _contextManager, + requestContext + ); + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + // Assert — structured response or text fallback + Assert.NotNull(resultDict); + Assert.True(resultDict.TryGetValue("uri", out var uriElement)); + Assert.Equal(uri, uriElement.GetString()); + if (resultDict.TryGetValue("isSessionSpecific", out var isSessionSpecific)) + { + Assert.True(isSessionSpecific.GetBoolean()); + Assert.True(resultDict.TryGetValue("contextId", out var contextIdElement)); + Assert.Equal("test-context-123", contextIdElement.GetString()); + } + else + { + Assert.True(resultDict.TryGetValue("text", out var textElem)); + var text = textElem.GetString() ?? string.Empty; + Assert.Contains("Is Session Specific: True", text); + Assert.Contains("Context ID: test-context-123", text); + } + } +} diff --git a/tests/RoslynStone.Tests/RoslynScriptingServiceTests.cs b/tests/RoslynStone.Tests/RoslynScriptingServiceTests.cs new file mode 100644 index 0000000000000000000000000000000000000000..af99d9ad69e6b246f0bf1c009e71d088d7c692bf --- /dev/null +++ b/tests/RoslynStone.Tests/RoslynScriptingServiceTests.cs @@ -0,0 +1,324 @@ +using RoslynStone.Infrastructure.Services; + +namespace RoslynStone.Tests; + +/// +/// Tests for RoslynScriptingService +/// +[Trait("Category", "Unit")] +[Trait("Component", "REPL")] +public class RoslynScriptingServiceTests +{ + [Fact] + [Trait("Feature", "Execution")] + public async Task ExecuteAsync_SimpleExpression_ReturnsResult() + { + // Arrange + var service = new RoslynScriptingService(); + var code = "1 + 1"; + + // Act + var result = await service.ExecuteAsync(code); + + // Assert + Assert.True(result.Success); + Assert.Equal(2, result.ReturnValue); + Assert.Empty(result.Errors); + } + + [Fact] + [Trait("Feature", "Output")] + public async Task ExecuteAsync_ConsoleOutput_CapturesOutput() + { + // Arrange + var service = new RoslynScriptingService(); + var code = "Console.WriteLine(\"Hello, World!\");"; + + // Act + var result = await service.ExecuteAsync(code); + + // Assert + Assert.True(result.Success); + Assert.Contains("Hello, World!", result.Output); + } + + [Fact] + [Trait("Feature", "Validation")] + public async Task ExecuteAsync_CompilationError_ReturnsErrors() + { + // Arrange + var service = new RoslynScriptingService(); + var code = "int x = \"not a number\";"; + + // Act + var result = await service.ExecuteAsync(code); + + // Assert + Assert.False(result.Success); + Assert.NotEmpty(result.Errors); + } + + [Fact] + [Trait("Feature", "State")] + public async Task ExecuteAsync_MultipleStatements_MaintainsState() + { + // Arrange + var service = new RoslynScriptingService(); // Use same instance for both calls + var code1 = "int x = 10; x"; // Return x to ensure success + var code2 = "x + 5"; + + // Act + var result1 = await service.ExecuteAsync(code1); + var result2 = await service.ExecuteAsync(code2); + + // Assert + Assert.True( + result1.Success, + $"First execution failed: {string.Join(", ", result1.Errors.Select(e => e.Message))}" + ); + Assert.Equal(10, result1.ReturnValue); + Assert.True( + result2.Success, + $"Second execution failed: {string.Join(", ", result2.Errors.Select(e => e.Message))}" + ); + Assert.Equal(15, result2.ReturnValue); + } + + [Fact] + [Trait("Feature", "Warnings")] + public async Task ExecuteAsync_Warning_ReturnsWarnings() + { + // Arrange + var service = new RoslynScriptingService(); + var code = "int x = 5; int y = 10;"; + + // Act + var result = await service.ExecuteAsync(code); + + // Assert + Assert.True(result.Success); + // Unused variables might generate warnings + } + + [Fact] + [Trait("Feature", "RuntimeError")] + public async Task ExecuteAsync_RuntimeException_ReturnsRuntimeError() + { + // Arrange + var service = new RoslynScriptingService(); + var code = "throw new System.InvalidOperationException(\"Test exception\");"; + + // Act + var result = await service.ExecuteAsync(code); + + // Assert + Assert.False(result.Success); + Assert.NotEmpty(result.Errors); + Assert.Contains(result.Errors, e => e.Code == "RUNTIME_ERROR"); + Assert.Contains(result.Errors, e => e.Message.Contains("Test exception")); + } + + [Fact] + [Trait("Feature", "RuntimeError")] + public async Task ExecuteAsync_DivideByZero_ReturnsRuntimeError() + { + // Arrange + var service = new RoslynScriptingService(); + var code = "int x = 10; int y = 0; int z = x / y;"; + + // Act + var result = await service.ExecuteAsync(code); + + // Assert + Assert.False(result.Success); + Assert.NotEmpty(result.Errors); + Assert.Contains(result.Errors, e => e.Code == "RUNTIME_ERROR"); + } + + [Fact] + [Trait("Feature", "RuntimeError")] + public async Task ExecuteAsync_NullReferenceException_ReturnsRuntimeError() + { + // Arrange + var service = new RoslynScriptingService(); + var code = "string s = null; var length = s.Length;"; + + // Act + var result = await service.ExecuteAsync(code); + + // Assert + Assert.False(result.Success); + Assert.NotEmpty(result.Errors); + Assert.Contains(result.Errors, e => e.Code == "RUNTIME_ERROR"); + } + + [Fact] + [Trait("Feature", "Cancellation")] + public async Task ExecuteAsync_CancellationRequested_ThrowsTaskCanceledException() + { + // Arrange + var service = new RoslynScriptingService(); + var code = "System.Threading.Thread.Sleep(5000);"; + using var cts = new CancellationTokenSource(); + cts.Cancel(); // Cancel immediately + + // Act & Assert - TaskCanceledException is a subclass of OperationCanceledException + await Assert.ThrowsAnyAsync(async () => + await service.ExecuteAsync(code, cts.Token) + ); + } + + [Fact] + [Trait("Feature", "Reset")] + public async Task Reset_AfterExecution_ClearsState() + { + // Arrange + var service = new RoslynScriptingService(); + var code1 = "int x = 10;"; + + // Act + await service.ExecuteAsync(code1); + service.Reset(); + var result = await service.ExecuteAsync("x"); + + // Assert - x should no longer exist after reset + Assert.False(result.Success); + Assert.NotEmpty(result.Errors); + } + + [Fact] + [Trait("Feature", "Reset")] + public async Task Reset_ClearsConsoleOutput() + { + // Arrange + var service = new RoslynScriptingService(); + await service.ExecuteAsync("Console.WriteLine(\"Test\");"); + + // Act + service.Reset(); + var result = await service.ExecuteAsync("Console.WriteLine(\"After reset\");"); + + // Assert + Assert.True(result.Success); + Assert.DoesNotContain("Test", result.Output); + Assert.Contains("After reset", result.Output); + } + + [Fact] + [Trait("Feature", "State")] + public async Task ExecuteAsync_FirstExecution_CreatesNewScriptState() + { + // Arrange + var service = new RoslynScriptingService(); + var code = "var greeting = \"Hello\";"; + + // Act + var result = await service.ExecuteAsync(code); + + // Assert + Assert.True(result.Success); + Assert.Empty(result.Errors); + } + + [Fact] + [Trait("Feature", "State")] + public async Task ExecuteAsync_ContinuedExecution_UsesExistingState() + { + // Arrange + var service = new RoslynScriptingService(); + await service.ExecuteAsync("var greeting = \"Hello\";"); + + // Act - Continue with existing state + var result = await service.ExecuteAsync("greeting + \" World\""); + + // Assert + Assert.True(result.Success); + Assert.Equal("Hello World", result.ReturnValue); + } + + [Fact] + [Trait("Feature", "ExecutionTime")] + public async Task ExecuteAsync_TracksExecutionTime() + { + // Arrange + var service = new RoslynScriptingService(); + var code = "1 + 1"; + + // Act + var result = await service.ExecuteAsync(code); + + // Assert + Assert.True(result.Success); + Assert.True(result.ExecutionTime.TotalMilliseconds >= 0); + } + + [Fact] + [Trait("Feature", "ExecutionTime")] + public async Task ExecuteAsync_CompilationError_TracksExecutionTime() + { + // Arrange + var service = new RoslynScriptingService(); + var code = "invalid code"; + + // Act + var result = await service.ExecuteAsync(code); + + // Assert + Assert.False(result.Success); + Assert.True(result.ExecutionTime.TotalMilliseconds >= 0); + } + + [Fact] + [Trait("Feature", "Output")] + public async Task ExecuteAsync_MultipleConsoleWrites_CapturesAllOutput() + { + // Arrange + var service = new RoslynScriptingService(); + var code = + @" +Console.Write(""Line1""); +Console.WriteLine(); +Console.Write(""Line2""); +"; + + // Act + var result = await service.ExecuteAsync(code); + + // Assert + Assert.True(result.Success); + Assert.Contains("Line1", result.Output); + Assert.Contains("Line2", result.Output); + } + + [Fact] + [Trait("Feature", "Output")] + public async Task ExecuteAsync_EmptyOutput_ReturnsEmptyString() + { + // Arrange + var service = new RoslynScriptingService(); + var code = "1 + 1"; // No console output + + // Act + var result = await service.ExecuteAsync(code); + + // Assert + Assert.True(result.Success); + Assert.Equal(string.Empty, result.Output); + } + + [Fact] + [Trait("Feature", "ScriptOptions")] + public void ScriptOptions_ReturnsConfiguredOptions() + { + // Arrange + var service = new RoslynScriptingService(); + + // Act + var options = service.ScriptOptions; + + // Assert + Assert.NotNull(options); + Assert.NotEmpty(options.MetadataReferences); + Assert.NotEmpty(options.Imports); + } +} diff --git a/tests/RoslynStone.Tests/RoslynStone.Tests.csproj b/tests/RoslynStone.Tests/RoslynStone.Tests.csproj new file mode 100644 index 0000000000000000000000000000000000000000..752bc571abe48cb8f27fc03435e93008b9e31a32 --- /dev/null +++ b/tests/RoslynStone.Tests/RoslynStone.Tests.csproj @@ -0,0 +1,26 @@ + + + net10.0 + 14 + enable + enable + false + true + + + + + + + + + + + + + + + + + + diff --git a/tests/RoslynStone.Tests/SecurityIsolationTests.cs b/tests/RoslynStone.Tests/SecurityIsolationTests.cs new file mode 100644 index 0000000000000000000000000000000000000000..c06cf175d87e98a80dc5509a827b43d6913d2917 --- /dev/null +++ b/tests/RoslynStone.Tests/SecurityIsolationTests.cs @@ -0,0 +1,211 @@ +// ReSharper disable RedundantUsingDirective - Required for test infrastructure +using System.Text.Json; +using RoslynStone.Core.Models; +using RoslynStone.Infrastructure.Services; +using RoslynStone.Infrastructure.Tools; +using RoslynStone.Tests.Serialization; +using Xunit; + +namespace RoslynStone.Tests; + +/// +/// Security tests for session isolation and resource protection +/// These tests verify the security findings from SECURITY_AUDIT_REPORT.md +/// +[Trait("Category", "Security")] +public class SecurityIsolationTests +{ + [Fact] + [Trait("Finding", "1")] + [Trait("Severity", "Critical")] + public async Task NuGetPackagesParameter_ProperlyIsolated_SAFE() + { + // This test shows the SAFE alternative to LoadNuGetPackage + // Using nugetPackages parameter creates context-specific isolation + + // Arrange + var service = new RoslynScriptingService(); + var contextMgr = new ReplContextManager(); + using var nugetSvc = new NuGetService(); + + // Act - User A loads package via nugetPackages parameter + var userAResult = await ReplTools.EvaluateCsharp( + service, + contextMgr, + nugetSvc, + "using Humanizer; \"test\".Humanize()", + nugetPackages: new[] + { + new NuGetPackageSpec { PackageName = "Humanizer", Version = "2.14.1" }, + }, + createContext: true + ); + var userAJson = TestJsonContext.SerializeDynamic(userAResult); + var userADict = TestJsonContext.DeserializeToDictionary(userAJson); + + Assert.NotNull(userADict); + Assert.True(userADict["success"].GetBoolean(), "User A should successfully use package"); + + // User B (separate context) tries to use the same package WITHOUT loading it + var userBResult = await ReplTools.EvaluateCsharp( + service, + contextMgr, + nugetSvc, + "using Humanizer; \"test\".Humanize()", + createContext: true // New context, NO nugetPackages parameter + ); + var userBJson = TestJsonContext.SerializeDynamic(userBResult); + var userBDict = TestJsonContext.DeserializeToDictionary(userBJson); + + // Assert - PROPER ISOLATION: User B does NOT have access! + Assert.NotNull(userBDict); + Assert.False( + userBDict["success"].GetBoolean(), + "User B should NOT have access to User A's package" + ); + + var errors = userBDict["errors"].EnumerateArray().ToList(); + Assert.NotEmpty(errors); + Assert.Contains(errors, e => e.GetProperty("message").GetString()!.Contains("Humanizer")); + + // This demonstrates proper session isolation ✓ + } + + [Fact(Skip = "Requires timeout implementation - see Finding #2")] + [Trait("Finding", "2")] + [Trait("Severity", "Critical")] + public async Task ExecuteAsync_InfiniteLoop_ShouldTimeout() + { + // This test is SKIPPED because the fix is not yet implemented + // After implementing Finding #2 fix, enable this test + + var service = new RoslynScriptingService(); + var contextMgr = new ReplContextManager(); + using var nugetSvc = new NuGetService(); + + // Act - Execute infinite loop + var result = await ReplTools.EvaluateCsharp( + service, + contextMgr, + nugetSvc, + "while(true) { }", // Infinite loop + createContext: false + ); + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + // Assert - Should timeout after 30 seconds (default) + Assert.NotNull(resultDict); + Assert.False(resultDict["success"].GetBoolean()); + + var errors = resultDict["errors"].EnumerateArray().ToList(); + Assert.Contains(errors, e => e.GetProperty("code").GetString() == "EXECUTION_TIMEOUT"); + } + + [Fact(Skip = "Requires memory limit implementation - see Finding #3")] + [Trait("Finding", "3")] + [Trait("Severity", "Critical")] + public async Task ExecuteAsync_LargeAllocation_ShouldFail() + { + // This test is SKIPPED because the fix is not yet implemented + // After implementing Finding #3 fix, enable this test + + var service = new RoslynScriptingService(); + var contextMgr = new ReplContextManager(); + using var nugetSvc = new NuGetService(); + + // Act - Try to allocate 2GB (should be blocked) + var result = await ReplTools.EvaluateCsharp( + service, + contextMgr, + nugetSvc, + "var bomb = new byte[int.MaxValue];", + createContext: false + ); + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + // Assert - Should fail due to memory limit + Assert.NotNull(resultDict); + Assert.False(resultDict["success"].GetBoolean()); + + var errors = resultDict["errors"].EnumerateArray().ToList(); + Assert.Contains(errors, e => e.GetProperty("code").GetString() == "MEMORY_LIMIT_EXCEEDED"); + } + + [Fact(Skip = "Requires filesystem restriction - see Finding #4")] + [Trait("Finding", "4")] + [Trait("Severity", "Critical")] + public async Task ExecuteAsync_FileAccess_ShouldBeBlocked() + { + // This test is SKIPPED because the fix is not yet implemented + // After implementing Finding #4 fix, enable this test + + var service = new RoslynScriptingService(); + var contextMgr = new ReplContextManager(); + using var nugetSvc = new NuGetService(); + + // Act - Try to read sensitive file + var result = await ReplTools.EvaluateCsharp( + service, + contextMgr, + nugetSvc, + @" + using System.IO; + File.ReadAllText(""/etc/passwd""); + ", + createContext: false + ); + var json = TestJsonContext.SerializeDynamic(result); + var resultDict = TestJsonContext.DeserializeToDictionary(json); + + // Assert - Should be blocked by static analysis or runtime restriction + Assert.NotNull(resultDict); + Assert.False(resultDict["success"].GetBoolean()); + + var errors = resultDict["errors"].EnumerateArray().ToList(); + Assert.Contains(errors, e => e.GetProperty("code").GetString() == "FORBIDDEN_API"); + } + + [Fact] + [Trait("Finding", "5")] + [Trait("Severity", "High")] + public async Task EvaluateCsharp_ContextId_ShouldNotBeGuessable() + { + // This test verifies context IDs are not trivially guessable + // After implementing Finding #5 fix (HMAC), verify signatures + + var service = new RoslynScriptingService(); + var contextMgr = new ReplContextManager(); + using var nugetSvc = new NuGetService(); + + // Act - Create multiple contexts + var contexts = new List(); + for (int i = 0; i < 10; i++) + { + var result = await ReplTools.EvaluateCsharp( + service, + contextMgr, + nugetSvc, + "int x = 1;", + createContext: true + ); + var json = TestJsonContext.SerializeDynamic(result); + var dict = TestJsonContext.DeserializeToDictionary(json); + var contextId = dict!["contextId"].GetString(); + contexts.Add(contextId!); + } + + // Assert - All context IDs should be unique + Assert.Equal(10, contexts.Distinct().Count()); + + // After implementing HMAC signatures: + // Assert - Context IDs should have signature component + // foreach (var contextId in contexts) + // { + // Assert.Contains(".", contextId); // Format: {guid}.{signature} + // var parts = contextId.Split('.'); + // Assert.Equal(2, parts.Length); + // } + } +} diff --git a/tests/RoslynStone.Tests/SecurityTests.cs b/tests/RoslynStone.Tests/SecurityTests.cs new file mode 100644 index 0000000000000000000000000000000000000000..46c38605df39fe767520e902ec2df5f429c80f4d --- /dev/null +++ b/tests/RoslynStone.Tests/SecurityTests.cs @@ -0,0 +1,408 @@ +using RoslynStone.Infrastructure.Helpers; +using RoslynStone.Infrastructure.Models; +using RoslynStone.Infrastructure.Services; + +namespace RoslynStone.Tests; + +/// +/// Security tests for timeout, memory limits, and other security features +/// +[Trait("Category", "Security")] +public class SecurityTests +{ + [Fact] + [Trait("Feature", "ExecutionTimeout")] + public async Task ExecuteAsync_LongRunningAsyncCode_TimesOut() + { + // Arrange + var config = new SecurityConfiguration + { + ExecutionTimeout = TimeSpan.FromSeconds(1), + EnableExecutionTimeout = true, + EnableMemoryLimits = false, + }; + var service = new RoslynScriptingService(config); + // Use async code that can be cancelled - tight synchronous loops cannot be interrupted + var code = "await Task.Delay(10000);"; // Try to wait 10 seconds + + // Act + var result = await service.ExecuteAsync(code); + + // Assert + Assert.False(result.Success); + Assert.NotEmpty(result.Errors); + Assert.Contains(result.Errors, e => e.Code == "EXECUTION_TIMEOUT"); + Assert.Contains("exceeded the timeout limit", result.Errors[0].Message); + } + + [Fact] + [Trait("Feature", "ExecutionTimeout")] + public async Task ExecuteAsync_LongRunningCode_CompletesWithinTimeout() + { + // Arrange + var config = new SecurityConfiguration + { + ExecutionTimeout = TimeSpan.FromSeconds(5), + EnableExecutionTimeout = true, + EnableMemoryLimits = false, + }; + var service = new RoslynScriptingService(config); + var code = "await Task.Delay(1000); return 42;"; // Takes 1 second + + // Act + var result = await service.ExecuteAsync(code); + + // Assert + Assert.True(result.Success); + Assert.Equal(42, result.ReturnValue); + } + + [Fact] + [Trait("Feature", "ExecutionTimeout")] + public async Task ExecuteAsync_TimeoutDisabled_FastCodeStillWorks() + { + // Arrange - Timeout is disabled, but use fast code to avoid blocking + var config = new SecurityConfiguration + { + ExecutionTimeout = TimeSpan.FromSeconds(1), + EnableExecutionTimeout = false, // Disabled + EnableMemoryLimits = false, + }; + var service = new RoslynScriptingService(config); + + // Use fast code instead of infinite loop + var code = "42"; + + // Act + var result = await service.ExecuteAsync(code); + + // Assert - Should succeed without timeout enforcement + Assert.True(result.Success); + Assert.Equal(42, result.ReturnValue); + } + + [Fact] + [Trait("Feature", "MemoryLimit")] + public void ResourceMonitor_ExcessiveMemoryAllocation_DetectsLimit() + { + // Arrange + var maxMemoryBytes = 100 * 1024 * 1024; // 100 MB limit + + // Act & Assert + // Note: This test checks if memory monitoring works, but the actual enforcement + // depends on the code execution monitoring the memory in a task + var isExceeded = ResourceMonitor.IsMemoryLimitExceeded(maxMemoryBytes); + + // The result depends on current process memory usage + // This is more of a smoke test that the method works + Assert.IsType(isExceeded); + } + + [Fact] + [Trait("Feature", "MemoryLimit")] + public void ResourceMonitor_GetCurrentMemoryUsage_ReturnsPositiveValue() + { + // Act + var memoryUsage = ResourceMonitor.GetCurrentMemoryUsage(); + var memoryUsageMb = ResourceMonitor.GetCurrentMemoryUsageMb(); + + // Assert + Assert.True(memoryUsage > 0); + Assert.True(memoryUsageMb > 0); + } + + [Fact] + [Trait("Feature", "MemoryLimit")] + public void ResourceMonitor_NoMemoryLimit_NeverExceeds() + { + // Arrange + var noLimit = 0L; + + // Act + var isExceeded = ResourceMonitor.IsMemoryLimitExceeded(noLimit); + + // Assert + Assert.False(isExceeded); + } + + [Fact] + [Trait("Feature", "SecurityConfiguration")] + public void SecurityConfiguration_ProductionDefaults_HasSecureSettings() + { + // Act + var config = SecurityConfiguration.CreateProductionDefaults(); + + // Assert + Assert.True(config.EnableExecutionTimeout); + Assert.True(config.EnableMemoryLimits); + Assert.True(config.EnableFilesystemRestrictions); + Assert.False(config.LogContextIds); // Should not log context IDs + Assert.Equal(TimeSpan.FromSeconds(30), config.ExecutionTimeout); + Assert.Equal(512 * 1024 * 1024, config.MaxMemoryBytes); + Assert.NotEmpty(config.BlockedFilesystemPaths); + } + + [Fact] + [Trait("Feature", "SecurityConfiguration")] + public void SecurityConfiguration_DevelopmentDefaults_HasPermissiveSettings() + { + // Act + var config = SecurityConfiguration.CreateDevelopmentDefaults(); + + // Assert + Assert.True(config.EnableExecutionTimeout); + Assert.False(config.EnableMemoryLimits); // Disabled in dev + Assert.False(config.EnableFilesystemRestrictions); // Disabled in dev + Assert.True(config.LogContextIds); // OK in dev + Assert.Equal(TimeSpan.FromMinutes(5), config.ExecutionTimeout); + Assert.Equal(0, config.MaxMemoryBytes); // No limit + } + + [Fact] + [Trait("Feature", "AssemblyExecution")] + public async Task AssemblyExecutionService_WithTimeout_StopsLongRunningAsyncCode() + { + // Arrange + var config = new SecurityConfiguration + { + ExecutionTimeout = TimeSpan.FromSeconds(1), + EnableExecutionTimeout = true, + EnableMemoryLimits = false, + }; + var compilationService = new CompilationService(); + var executionService = new AssemblyExecutionService(compilationService, config); + var code = + @" +using System; +using System.Threading.Tasks; + +public class Program +{ + public static async Task Main() + { + await Task.Delay(10000); // Try to wait 10 seconds + } +}"; + + // Act + var result = await executionService.ExecuteCodeAsync(code); + + // Assert + Assert.False(result.Success); + Assert.Contains("exceeded the timeout limit", result.ErrorMessage ?? ""); + } + + [Fact] + [Trait("Feature", "ContextIsolation")] + public async Task RoslynScriptingService_MultipleInstances_IsolatedContexts() + { + // Arrange + var service1 = new RoslynScriptingService(); + var service2 = new RoslynScriptingService(); + + // Act - Set variable in service1 + var result1 = await service1.ExecuteAsync("var x = 42; x"); + Assert.True(result1.Success); + Assert.Equal(42, result1.ReturnValue); + + // Try to access variable from service1 in service2 (should fail) + var result2 = await service2.ExecuteAsync("x"); + + // Assert - Variable should not be accessible in service2 + Assert.False(result2.Success); + Assert.NotEmpty(result2.Errors); + } + + [Fact] + [Trait("Feature", "ContextIsolation")] + public async Task RoslynScriptingService_Reset_ClearsState() + { + // Arrange + var service = new RoslynScriptingService(); + + // Act - Set variable + var result1 = await service.ExecuteAsync("var x = 42; x"); + Assert.True(result1.Success); + Assert.Equal(42, result1.ReturnValue); + + // Reset service + service.Reset(); + + // Try to access variable after reset (should fail) + var result2 = await service.ExecuteAsync("x"); + + // Assert - Variable should not be accessible after reset + Assert.False(result2.Success); + Assert.NotEmpty(result2.Errors); + } + + [Fact] + [Trait("Feature", "FilesystemSecurity")] + public async Task ExecuteAsync_FileAccess_BlockedByDefault() + { + // Arrange + var config = new SecurityConfiguration + { + EnableFilesystemRestrictions = true, + EnableExecutionTimeout = false, + EnableMemoryLimits = false, + }; + var service = new RoslynScriptingService(config); + var code = "File.ReadAllText(\"/etc/passwd\");"; + + // Act + var result = await service.ExecuteAsync(code); + + // Assert + Assert.False(result.Success); + Assert.NotEmpty(result.Errors); + Assert.Contains(result.Errors, e => e.Code == "FILESYSTEM_ACCESS_DENIED"); + } + + [Fact] + [Trait("Feature", "FilesystemSecurity")] + public async Task ExecuteAsync_ProcessStart_Blocked() + { + // Arrange + var config = new SecurityConfiguration + { + EnableFilesystemRestrictions = true, + EnableExecutionTimeout = false, + EnableMemoryLimits = false, + }; + var service = new RoslynScriptingService(config); + var code = "System.Diagnostics.Process.Start(\"cmd.exe\");"; + + // Act + var result = await service.ExecuteAsync(code); + + // Assert + Assert.False(result.Success); + Assert.NotEmpty(result.Errors); + Assert.Contains(result.Errors, e => e.Code == "FILESYSTEM_ACCESS_DENIED"); + } + + [Fact] + [Trait("Feature", "FilesystemSecurity")] + public async Task ExecuteAsync_FilesystemDisabled_AllowsAccess() + { + // Arrange + var config = new SecurityConfiguration + { + EnableFilesystemRestrictions = false, + EnableExecutionTimeout = false, + EnableMemoryLimits = false, + }; + var service = new RoslynScriptingService(config); + var code = "return 42;"; // Simple code that doesn't actually access filesystem + + // Act + var result = await service.ExecuteAsync(code); + + // Assert - Should succeed because restrictions are disabled + Assert.True(result.Success); + Assert.Equal(42, result.ReturnValue); + } + + [Fact] + [Trait("Feature", "SessionIdProtection")] + public void ContextIdMasker_WithMaskingEnabled_MasksContextId() + { + // Arrange + var contextId = "12345678-1234-1234-1234-123456789012"; + + // Act + var masked = ContextIdMasker.Mask(contextId, shouldMask: true); + + // Assert + Assert.NotEqual(contextId, masked); + Assert.StartsWith("12345678", masked); + Assert.DoesNotContain("123456789012", masked); + } + + [Fact] + [Trait("Feature", "SessionIdProtection")] + public void ContextIdMasker_WithMaskingDisabled_ReturnsOriginal() + { + // Arrange + var contextId = "12345678-1234-1234-1234-123456789012"; + + // Act + var masked = ContextIdMasker.Mask(contextId, shouldMask: false); + + // Assert + Assert.Equal(contextId, masked); + } + + [Fact] + [Trait("Feature", "SessionIdProtection")] + public void ContextIdMasker_WithNullContextId_ReturnsPlaceholder() + { + // Act + var masked = ContextIdMasker.Mask(null, shouldMask: true); + + // Assert + Assert.Equal("[null]", masked); + } + + [Fact] + [Trait("Feature", "SessionIdProtection")] + public void ContextIdMasker_WithShortContextId_MasksEntirely() + { + // Arrange + var contextId = "short"; + + // Act + var masked = ContextIdMasker.Mask(contextId, shouldMask: true); + + // Assert + Assert.Equal("*****", masked); + Assert.DoesNotContain("short", masked); + } + + [Fact] + [Trait("Feature", "SessionIdProtection")] + public void SecurityConfiguration_ProductionDefaults_DisablesContextIdLogging() + { + // Arrange + var config = SecurityConfiguration.CreateProductionDefaults(); + + // Assert + Assert.False(config.LogContextIds); + } + + [Fact] + [Trait("Feature", "SessionIdProtection")] + public void SecurityConfiguration_DevelopmentDefaults_EnablesContextIdLogging() + { + // Arrange + var config = SecurityConfiguration.CreateDevelopmentDefaults(); + + // Assert + Assert.True(config.LogContextIds); + } + + [Fact] + [Trait("Feature", "AssemblyBlocklist")] + public void SecurityConfiguration_ProductionDefaults_BlocksDangerousAssemblies() + { + // Arrange + var config = SecurityConfiguration.CreateProductionDefaults(); + + // Assert + Assert.NotEmpty(config.BlockedAssemblies); + Assert.Contains(config.BlockedAssemblies, a => a.Contains("InteropServices")); + Assert.Contains(config.BlockedAssemblies, a => a.Contains("Unsafe")); + } + + [Fact] + [Trait("Feature", "AssemblyBlocklist")] + public void SecurityConfiguration_DevelopmentDefaults_NoAssemblyRestrictions() + { + // Arrange + var config = SecurityConfiguration.CreateDevelopmentDefaults(); + + // Assert + Assert.Empty(config.BlockedAssemblies); + } +} diff --git a/tests/RoslynStone.Tests/Serialization/TestJsonContext.cs b/tests/RoslynStone.Tests/Serialization/TestJsonContext.cs new file mode 100644 index 0000000000000000000000000000000000000000..3f8f00e33ca414526723579450512342d04d7723 --- /dev/null +++ b/tests/RoslynStone.Tests/Serialization/TestJsonContext.cs @@ -0,0 +1,38 @@ +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace RoslynStone.Tests.Serialization; + +/// +/// Source-generated JSON serialization context for RoslynStone tests +/// Provides high-performance JSON serialization for test scenarios +/// +[JsonSourceGenerationOptions( + WriteIndented = false, + PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase, + DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull, + GenerationMode = JsonSourceGenerationMode.Default +)] +[JsonSerializable(typeof(Dictionary))] +[JsonSerializable(typeof(Dictionary))] +[JsonSerializable(typeof(List))] +[JsonSerializable(typeof(object))] +public partial class TestJsonContext : JsonSerializerContext +{ + /// + /// Helper to serialize dynamic tool results using reflection-based serialization + /// (source generators can't handle anonymous types) + /// + public static string SerializeDynamic(object value) + { + return JsonSerializer.Serialize(value); + } + + /// + /// Helper to deserialize to Dictionary using source-generated context + /// + public static Dictionary? DeserializeToDictionary(string json) + { + return JsonSerializer.Deserialize(json, Default.DictionaryStringJsonElement); + } +}